Exemplo n.º 1
0
        /// <summary>
        /// Parses inputed string, trying to read an int, passed as a reference.
        /// </summary>
        /// <param name="tmpString">Input string argument to be parsed.</param>
        /// <param name="resultInt">Reference on the result int.</param>
        /// <param name="isLast">Reference on a variable, indicating on success if read value was last in inputed string or not.</param>
        /// <param name="variableName">Name of parsed variable for error messages.</param>
        /// <param name="checkMode">Mode of checking read value to be positive, negative, etc.</param>
        /// <param name="delimiter">The delimiter string for parsing, default is ' '.</param>
        /// <returns>Empty string on success or error message.</returns>
        public static string ParseInt(ref string tmpString, ref int resultInt, ref bool isLast, string variableName, AfterParsingCheck checkMode, string delimiter = " ")
        {
            tmpString = tmpString.Trim();
            if (delimiter.Length == 1)
            {
                tmpString = tmpString.Trim(delimiter.ToCharArray());
            }

            if (tmpString.Length == 0)
            {
                return("Error parsing <" + variableName + "> - no argument inputed.");
            }

            int tmpInt = tmpString.IndexOf(delimiter);

            // CHECKING IF CURRENT ARGUMENT IS THE LAST
            if (tmpInt == -1)
            {
                // THE ARGUMENT IS LAST
                isLast = true;

                // TRYING TO PARSE THE INPUTED STRING
                if (!int.TryParse(tmpString, out resultInt))
                {
                    return("\n-> Error parsing <" + variableName + "> argument (" + tmpString + ").");
                }

                // EMPTYING ARGUMENT STRING
                tmpString = "";
            }
            else
            {
                // CURRENT ARGUMENT IS NOT THE LAST
                isLast = false;

                if (!int.TryParse(tmpString.Remove(tmpInt), out resultInt))
                {
                    return("\n-> Error parsing <" + variableName + "> argument (" + tmpString.Remove(tmpInt) + ").");
                }

                tmpString = tmpString.Remove(0, tmpInt + 1).Trim();
                if (delimiter.Length == 1)
                {
                    tmpString = tmpString.Trim(delimiter.ToCharArray());
                }
            }

            switch (checkMode)
            {
            case AfterParsingCheck.NoCheck:
                break;

            case AfterParsingCheck.NonNegative:
                if (resultInt < 0)
                {
                    return("\n-> Error: argument <" + variableName + "> is not non-negative (" + resultInt.ToString() + ").");
                }
                break;

            case AfterParsingCheck.Positive:
                if (resultInt <= 0)
                {
                    return("\n-> Error: argument <" + variableName + "> is not positive (" + resultInt.ToString() + ").");
                }
                break;

            case AfterParsingCheck.Negative:
                if (resultInt >= 0)
                {
                    return("\n-> Error: argument <" + variableName + "> is not negative (" + resultInt.ToString() + ").");
                }
                break;

            case AfterParsingCheck.NonPositive:
                if (resultInt > 0)
                {
                    return("\n-> Error: argument <" + variableName + "> is not non-positive (" + resultInt.ToString() + ").");
                }
                break;

            case AfterParsingCheck.Zero:
                if (resultInt != 0)
                {
                    return("\n-> Error: argument <" + variableName + "> is not a zero (" + resultInt.ToString() + ").");
                }
                break;

            case AfterParsingCheck.NonZero:
                if (resultInt == 0)
                {
                    return("\n-> Error: argument <" + variableName + "> is not non-zero (" + resultInt.ToString() + ").");
                }
                break;

            default:
                break;
            }

            return("");
        }
Exemplo n.º 2
0
        /// <summary>
        /// Parses inputed string, trying to read float array, passed as a reference.
        /// </summary>
        /// <param name="tmpString">Input string argument to be parsed.</param>
        /// <param name="resultArray">Reference on the result array.</param>
        /// <param name="isLast">Reference on a variable, indicating on success if read array was last in inputed string or not.</param>
        /// <param name="parseName">Name of parsed parameter for error messages.</param>
        /// <param name="checkMode">Mode of checking read values to be positive, negative, etc.</param>
        /// <param name="delimiter">The delimiter string for parsing, default is ' '.</param>
        /// <returns>Empty string on success or error message.</returns>
        public static string ParseFloatArray(ref string tmpString, ref float[] resultArray, ref bool isLast, string parseName, AfterParsingCheck checkMode, string delimiter = " ")
        {
            // CHECKING INPUT
            if (tmpString.Length == 0)
            {
                return("\n-> Error parsing " + parseName + ": empty input text.");
            }

            string result = "";

            // RUNNING THROUGH ALL ALREADY CREATED ARRAY
            for (int i = 0; i < resultArray.Length; i++)
            {
                result = ParseFloat(ref tmpString, ref resultArray[i], ref isLast, parseName, checkMode, delimiter);

                if (result.Length > 0)
                {
                    return(result);
                }

                if ((isLast) && (i < resultArray.Length - 1))
                {
                    return("\n-> Error parsing " + parseName + ": no input text for unit " + i.ToString() + " .");
                }
            }
            return("");
        }