/// <summary> /// Parse the message arguments from the specified String using the rules of /// this MessageFormat. /// </summary> /// /// <param name="string">the String to parse</param> /// <returns>the array of Object arguments resulting from the parse</returns> /// <exception cref="ParseException">when an error occurs during parsing</exception> public Object[] Parse(String str0) { ParsePosition position = new ParsePosition(0); Object[] result = Parse(str0, position); if (position.GetErrorIndex() != -1 || position.GetIndex() == 0) { throw new ILOG.J2CsMapping.Util.ParseException(null, position.GetErrorIndex()); } return(result); }
/// <summary> /// Parse a Number from the specified String using the rules of this /// NumberFormat. /// </summary> /// /// <param name="string">the String to parse</param> /// <returns>the Number resulting from the parse</returns> /// <exception cref="ParseException">when an error occurs during parsing</exception> public object Parse(String str0) { ParsePosition pos = new ParsePosition(0); object number = Parse(str0, pos); if (pos.GetErrorIndex() != -1 || pos.GetIndex() == 0) { throw new ILOG.J2CsMapping.Util.ParseException(null, pos.GetErrorIndex()); } return(number); }
/// <summary> /// Parse a Date from the specified String using the rules of this /// DateFormat. /// </summary> /// /// <param name="string">the String to parse</param> /// <returns>the Date resulting from the parse</returns> /// <exception cref="ParseException">when an error occurs during parsing</exception> public DateTime Parse(String str0) { ParsePosition position = new ParsePosition(0); DateTime date = Parse(str0, position); if (position.GetErrorIndex() != -1 || position.GetIndex() == 0) { // text.19=Unparseable date: {0} throw new ILOG.J2CsMapping.Util.ParseException("text.19" + str0 + position.GetErrorIndex()); //$NON-NLS-1$ } return(date); }
/// <summary> /// Parse the message argument from the specified String starting at the /// index specified by the ParsePosition. If the string is successfully /// parsed, the index of the ParsePosition is updated to the index following /// the parsed text. /// </summary> /// /// <param name="string">the String to parse</param> /// <param name="position">the ParsePosition, updated on return with the index followingthe parsed text, or on error the index is unchanged and theerror index is set to the index where the error occurred</param> /// <returns>the array of Object arguments resulting from the parse, or null /// if there is an error</returns> public Object[] Parse(String str0, ParsePosition position) { if (str0 == null) { return(new Object[0]); } ParsePosition internalPos = new ParsePosition(0); int offset = position.GetIndex(); Object[] result = new Object[maxArgumentIndex + 1]; for (int i = 0; i <= maxOffset; i++) { String sub = strings[i]; if (!ILOG.J2CsMapping.Util.StringUtil.StartsWith(str0, sub, offset)) { position.SetErrorIndex(offset); return(null); } offset += sub.Length; Object parse; Format format = formats[i]; if (format == null) { if (i + 1 < strings.Length) { int next = ILOG.J2CsMapping.Util.StringUtil.IndexOf(str0, strings[i + 1], offset); if (next == -1) { position.SetErrorIndex(offset); return(null); } parse = str0.Substring(offset, (next) - (offset)); offset = next; } else { parse = str0.Substring(offset); offset = str0.Length; } } else { internalPos.SetIndex(offset); parse = format.ParseObject(str0, internalPos); if (internalPos.GetErrorIndex() != -1) { position.SetErrorIndex(offset); return(null); } offset = internalPos.GetIndex(); } result[argumentNumbers[i]] = parse; } if (maxOffset + 1 < strings.Length) { String sub_0 = strings[maxOffset + 1]; if (!ILOG.J2CsMapping.Util.StringUtil.StartsWith(str0, sub_0, offset)) { position.SetErrorIndex(offset); return(null); } offset += sub_0.Length; } position.SetIndex(offset); return(result); }
/// <summary> /// Parses the pattern to determine new strings and ranges for this /// ChoiceFormat. /// </summary> /// /// <param name="template">the pattern of strings and ranges</param> /// <exception cref="IllegalArgumentException">then an error occurs parsing the pattern</exception> public void ApplyPattern(String template) { double[] limits = new double[5]; IList <String> formats = new List <String>(); int length = template.Length, limitCount = 0, index = 0; StringBuilder buffer = new StringBuilder(); IBM.ICU.Text.NumberFormat format = IBM.ICU.Text.NumberFormat.GetInstance(ILOG.J2CsMapping.Util.Locale.US); ParsePosition position = new ParsePosition(0); while (true) { index = SkipWhitespace(template, index); if (index >= length) { if (limitCount == limits.Length) { choiceLimits = limits; } else { choiceLimits = new double[limitCount]; System.Array.Copy((Array)(limits), 0, (Array)(choiceLimits), 0, limitCount); } choiceFormats = new String[formats.Count]; for (int i = 0; i < formats.Count; i++) { choiceFormats[i] = formats[i]; } return; } position.SetIndex(index); object value_ren = format.Parse(template, position); index = SkipWhitespace(template, position.GetIndex()); if (position.GetErrorIndex() != -1 || index >= length) { // Fix Harmony 540 choiceLimits = new double[0]; choiceFormats = new String[0]; return; } char ch = template[index++]; if (limitCount == limits.Length) { double[] newLimits = new double[limitCount * 2]; System.Array.Copy((Array)(limits), 0, (Array)(newLimits), 0, limitCount); limits = newLimits; } double next; switch ((int)ch) { case '#': case '\u2264': next = Convert.ToDouble(value_ren); break; case '<': next = NextDouble(Convert.ToDouble(value_ren)); break; default: throw new ArgumentException(); } if (limitCount > 0 && next <= limits[limitCount - 1]) { throw new ArgumentException(); } buffer.Length = 0; position.SetIndex(index); ILOG.J2CsMapping.Formatting.Format.UpTo(template, position, buffer, '|'); index = position.GetIndex(); limits[limitCount++] = next; ILOG.J2CsMapping.Collections.Generics.Collections.Add(formats, buffer.ToString()); } }