C# Group.RemoveRange方法代码示例

        /// <summary>
        /// Parses the logical comparisons of the group. Replaces the operators and operands in the group with their
        /// results.
        /// </summary>
        /// <param name="group">The group to parse.</param>
        /// <returns>A TException on failure, otherwise null.</returns>
        TException ParseComparisonsOfGroup(Group group)
        {
            int index;
            while ((index = group.IndexOf("=")) >= 0)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '='");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TType result = Operations.Equal(this, a, b, true);
                if (result == null) return new TException(this, "Comparison operation failed", "reason unknown");
                if (result is TException) return result as TException;
                group[index - 1] = result;
                group.RemoveRange(index, 2);
            }

            while ((index = group.IndexOf("~=")) >= 0) // Approximately equal (by rounding or within ~0.5)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '~='");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TType result = Operations.Equal(this, a, b, false);
                if (result is TException) return result as TException;
                group[index - 1] = result;
                group.RemoveRange(index, 2);
            }

            while ((index = group.IndexOf("/=")) >= 0) // Not equal
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '/='");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TType result = Operations.NotEqual(this, a, b);
                if (result == null) return new TException(this, "Comparison operation failed", "reason unknown");
                if (result is TException) return result as TException;
                group[index - 1] = result;
                group.RemoveRange(index, 2);
            }

            while ((index = group.IndexOf("<")) >= 0)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '<'");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TType result = Operations.Math.Inequality(this, a, b, "<");
                if (result == null) return new TException(this, "Less than comparison failed", "reason unknown");
                if (result is TException) return result as TException;
                group[index - 1] = result;
                group.RemoveRange(index, 2);
            }

            while ((index = group.IndexOf(">")) >= 0)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '<'");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TType result = Operations.Math.Inequality(this, a, b, ">");
                if (result == null)
                    return new TException(this, "Greater than comparison failed", "reason unknown");
                if (result is TException) return result as TException;
                group[index - 1] = result;
                group.RemoveRange(index, 2);
            }

            while ((index = group.IndexOf("<=")) >= 0)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '<'");

                TType a = TType.Parse(this, group[index - 1]);
//.........这里部分代码省略.........

        /// <summary>
        /// Parses the commas in the group, converting a comma separated list into a TArgumentList, and replacing the
        /// list in the group with it.
        /// </summary>
        /// <param name="group">The group to parse.</param>
        /// <returns>A TException on failure, otherwise null.</returns>
        TException ParseCommasOfGroup(Group group)
        {
            int index;
            while ((index = group.IndexOf(",")) >= 0)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term ','");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TArgumentList argList = a as TArgumentList;
                if (argList == null)
                {
                    argList = new TArgumentList();
                    argList.Add(a);
                    argList.Add(b);
                }
                else argList.Add(b);

                group[index - 1] = argList;
                group.RemoveRange(index, 2);
            }

            return null;
        }

        /// <summary>
        /// Parses a group, searching for any modulus brackets and replacing the modulus brackets and their contents
        /// with the absolute values.
        /// </summary>
        /// <param name="group">The group to parse.</param>
        /// <returns>A TException on failure, otherwise null.</returns>
        TException ParseModulusBracketsOfGroup(Group group)
        {
            int index;
            while ((index = group.IndexOf(TType.MODULUS_CHARACTER.ToString())) >= 0)
            {
                TException exception = new TException(this, "Modulus brackets not closed", "another | required");
                if (index + 2 >= group.Count) return exception;
                if (group[index + 2] is string)
                {
                    if ((string)group[index + 2] != TType.MODULUS_CHARACTER.ToString()) return exception;
                }
                else return exception;

                TType value = TType.Parse(this, group[index + 1]);
                if (value is TException) return value as TException;

                TType result = Operations.Math.Modulus(this, value);
                if (result == null) return new TException(this, "Modulus operation failed", "reason unknown");
                if (result is TException) return result as TException;
                group[index] = result;
                group.RemoveRange(index + 1, 2);
            }

            return null;
        }

        /// <summary>
        /// Parses all of the arithmetic in the group, according to BIDMAS (although ignoring Brackets, because
        /// they're taken care of elsewhere), replacing the operands and operators with the results.
        /// </summary>
        /// <param name="group">The group to parse.</param>
        /// <returns>A TException on failure, otherwise null.</returns>
        TException ParseBidmasOfGroup(Group group)
        {
            // For every while loop, convert the values either side of the operator to the relevant TType, and attempt
            // to perform the operation on them. Then replace the operands and operator in the group with the result

            int index;
            while ((index = group.IndexOf("^")) >= 0) // Indicies
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '^'");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TType result = Operations.Math.Pow(this, a, b);
                if (result == null) return new TException(this, "Exponentiation operation failed", "reason unknown");
                if (result is TException) return result as TException;
                group[index - 1] = result;
                group.RemoveRange(index, 2);
            }

            while (true) // Division and Multiplication
            {
                // Find out which operator comes first in order to parse the expression from left to right
                int divIndex = group.IndexOf("/"), mulIndex = group.IndexOf("*");
                if (divIndex < 0) index = mulIndex;
                else if (mulIndex < 0) index = divIndex;
                else index = divIndex < mulIndex ? divIndex : mulIndex;
                if (index < 0) break;

                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term '" + group[index] + "'");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TType result;
                if ((string)group[index] == "/")
                {
                    result = Operations.Math.Divide(this, a, b);
                    if (result == null) return new TException(this, "Division operation failed", "reason unknown");
                }
                else
                {
                    result = Operations.Math.Multiply(this, a, b);
                    if (result == null)
                        return new TException(this, "Multiplication operation failed", "reason unknown");
                }

                if (result is TException) return result as TException;
                group[index - 1] = result;
                group.RemoveRange(index, 2);
            }

            while (true) // Addition and Subtraction
            {
                int addIndex = group.IndexOf("+"), subIndex = group.IndexOf("-");
                if (addIndex < 0) index = subIndex;
                else if (subIndex < 0) index = addIndex;
                else index = addIndex < subIndex ? addIndex : subIndex;
                if (index < 0) break;

                char operatorChar = ((string)group[index])[0];

                if (index - 1 < 0)
                { // There's no number before the operator, so perform a unary operation
                    TException exception = ParseUnaryArtitmetic(group, index, operatorChar);
                    if (exception != null) return exception;
                    continue;
                }
                else if (index + 1 >= group.Count)
                    return new TException(this, "Invalid expression term '" + group[index] + "'");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException)
                {
                    string possibleOperator = group[index - 1] as string;
                    if (possibleOperator != null)
                    {
                        if (RESERVED_SYMBOLS.Contains(possibleOperator))
                        {
                            TException exception = ParseUnaryArtitmetic(group, index, operatorChar);
                            if (exception != null) return exception;
                            continue;
                        }
                    }
                    return a as TException;
                }
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;
//.........这里部分代码省略.........

        /// <summary>
        /// Parses the logical operators of the group. Replaces the operators and operands with their results.
        /// </summary>
        /// <param name="group">The group to parse.</param>
        /// <returns>A TException on failure, otherwise null.</returns>
        TException ParseLogicalOperatorsOfGroup(Group group)
        {
            int index;
            while ((index = group.IndexOf("and")) >= 0)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term ','");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TBoolean aBool = a as TBoolean;
                if (aBool == null)
                    return new TException(this, "Left hand side of expression must be a boolean value", "yes or no");
                TBoolean bBool = b as TBoolean;
                if (bBool == null)
                    return new TException(this, "Right hand side of expression must be a boolean value", "yes or no");

                group[index - 1] = new TBoolean(aBool.Value && bBool.Value);
                group.RemoveRange(index, 2);
            }

            while ((index = group.IndexOf("or")) >= 0)
            {
                if ((index - 1 < 0) || (index + 1 >= group.Count))
                    return new TException(this, "Invalid expression term ','");

                TType a = TType.Parse(this, group[index - 1]);
                if (a is TException) return a as TException;
                TType b = TType.Parse(this, group[index + 1]);
                if (b is TException) return b as TException;

                TBoolean aBool = a as TBoolean;
                if (aBool == null)
                    return new TException(this, "Left hand side of expression must be a boolean value", "yes or no");
                TBoolean bBool = b as TBoolean;
                if (bBool == null)
                    return new TException(this, "Right hand side of expression must be a boolean value", "yes or no");

                group[index - 1] = new TBoolean(aBool.Value || bBool.Value);
                group.RemoveRange(index, 2);
            }

            return null;
        }