public static DateTime ToDateTime(string s, string[] formats)
{
foreach (var format in formats)
{
var simpleDateFormat = new SimpleDateFormat(ToJavaFormat(format), Locale.US);
var parsePosition = new ParsePosition(0);
var date = simpleDateFormat.Parse(s, parsePosition);
if (date != null && parsePosition.Index != 0) return DateTime.FromDate(date);
}
throw new ArgumentException(s + " cannot be parsed as DateTime");
}
/// <summary> /// Parse a Date 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 Date resulting from the parse, or null if there is an error</returns> public abstract DateTime Parse(String str0, ParsePosition position);
bool ParseEOS(ParsePosition position)
{
return(position.ReachedEnd);
}
/// <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());
}
}
// -----------------------------------------------------------------------
// parsing
// -----------------------------------------------------------------------
/// <summary>
/// Parses a string. Matches the string to be parsed against each of its
/// rules (with a base value less than upperBound) and returns the value
/// produced by the rule that matched the most charcters in the source
/// string.
/// </summary>
///
/// <param name="text">The string to parse</param>
/// <param name="parsePosition">The initial position is ignored and assumed to be 0. On exit,this object has been updated to point to the first characterposition this rule set didn't consume.</param>
/// <param name="upperBound">Limits the rules that can be allowed to match. Only ruleswhose base values are strictly less than upperBound areconsidered.</param>
/// <returns>The numerical result of parsing this string. This will be the
/// matching rule's base value, composed appropriately with the
/// results of matching any of its substitutions. The object will be
/// an instance of Long if it's an integral value; otherwise, it will
/// be an instance of Double. This function always returns a valid
/// object: If nothing matched the input string at all, this function
/// returns new Long(0), and the parse position is left unchanged.</returns>
public object Parse(String text, ParsePosition parsePosition,
double upperBound)
{
// try matching each rule in the rule set against the text being
// parsed. Whichever one matches the most characters is the one
// that determines the value we return.
ParsePosition highWaterMark = new ParsePosition(0);
object result = (long)(0);
object tempResult = null;
// dump out if there's no text to parse
if (text.Length == 0)
{
return(result);
}
// start by trying the nehative number rule (if there is one)
if (negativeNumberRule != null)
{
tempResult = negativeNumberRule.DoParse(text, parsePosition, false,
upperBound);
if (parsePosition.GetIndex() > highWaterMark.GetIndex())
{
result = tempResult;
highWaterMark.SetIndex(parsePosition.GetIndex());
}
// commented out because the error-index API on ParsePosition isn't
// there in 1.1.x
// if (parsePosition.getErrorIndex() >
// highWaterMark.getErrorIndex()) {
// highWaterMark.setErrorIndex(parsePosition.getErrorIndex());
// }
parsePosition.SetIndex(0);
}
// then try each of the fraction rules
for (int i = 0; i < 3; i++)
{
if (fractionRules[i] != null)
{
tempResult = fractionRules[i].DoParse(text, parsePosition,
false, upperBound);
if (parsePosition.GetIndex() > highWaterMark.GetIndex())
{
result = tempResult;
highWaterMark.SetIndex(parsePosition.GetIndex());
}
// commented out because the error-index API on ParsePosition
// isn't there in 1.1.x
// if (parsePosition.getErrorIndex() >
// highWaterMark.getErrorIndex()) {
// highWaterMark.setErrorIndex(parsePosition.getErrorIndex());
// }
parsePosition.SetIndex(0);
}
}
// finally, go through the regular rules one at a time. We start
// at the end of the list because we want to try matching the most
// sigificant rule first (this helps ensure that we parse
// "five thousand three hundred six" as
// "(five thousand) (three hundred) (six)" rather than
// "((five thousand three) hundred) (six)"). Skip rules whose
// base values are higher than the upper bound (again, this helps
// limit ambiguity by making sure the rules that match a rule's
// are less significant than the rule containing the substitutions)/
for (int i_0 = rules.Length - 1; i_0 >= 0 &&
highWaterMark.GetIndex() < text.Length; i_0--)
{
if (!isFractionRuleSet && rules[i_0].GetBaseValue() >= upperBound)
{
continue;
}
tempResult = rules[i_0].DoParse(text, parsePosition,
isFractionRuleSet, upperBound);
if (parsePosition.GetIndex() > highWaterMark.GetIndex())
{
result = tempResult;
highWaterMark.SetIndex(parsePosition.GetIndex());
}
// commented out because the error-index API on ParsePosition isn't
// there in 1.1.x
// if (parsePosition.getErrorIndex() >
// highWaterMark.getErrorIndex()) {
// highWaterMark.setErrorIndex(parsePosition.getErrorIndex());
// }
parsePosition.SetIndex(0);
}
// finally, update the parse postion we were passed to point to the
// first character we didn't use, and return the result that
// cporresponds to that string of characters
parsePosition.SetIndex(highWaterMark.GetIndex());
// commented out because the error-index API on ParsePosition isn't
// there in 1.1.x
// if (parsePosition.getIndex() == 0) {
// parsePosition.setErrorIndex(highWaterMark.getErrorIndex());
// }
return(result);
}
public override Number Parse(string @string, ParsePosition position)
{
return(null);
}
//----------------------------------------------------------------
// Private implementation
//----------------------------------------------------------------
/// <summary>
/// Parse an ID into component pieces. Take IDs of the form T,
/// T/V, S-T, S-T/V, or S/V-T. If the source is missing, return a
/// source of ANY.
/// </summary>
/// <param name="id">The id string, in any of several forms.</param>
/// <param name="pos">INPUT-OUTPUT parameter. On input, pos[0] is the
/// offset of the first character to parse in id. On output,
/// pos[0] is the offset after the last parsed character. If the
/// parse failed, pos[0] will be unchanged.</param>
/// <param name="allowFilter">If true, a <see cref="UnicodeSet"/> pattern is allowed
/// at any location between specs or delimiters, and is returned
/// as the fifth string in the array.</param>
/// <returns>A <see cref="Specs"/> object, or null if the parse failed. If
/// neither source nor target was seen in the parsed id, then the
/// parse fails. If <paramref name="allowFilter"/> is true, then the parsed filter
/// pattern is returned in the <see cref="Specs"/> object, otherwise the returned
/// filter reference is null. If the parse fails for any reason
/// null is returned.</returns>
private static Specs ParseFilterID(string id, int[] pos,
bool allowFilter)
{
string first = null;
string source = null;
string target = null;
string variant = null;
string filter = null;
char delimiter = (char)0;
int specCount = 0;
int start = pos[0];
// This loop parses one of the following things with each
// pass: a filter, a delimiter character (either '-' or '/'),
// or a spec (source, target, or variant).
for (; ;)
{
pos[0] = PatternProps.SkipWhiteSpace(id, pos[0]);
if (pos[0] == id.Length)
{
break;
}
// Parse filters
if (allowFilter && filter == null &&
UnicodeSet.ResemblesPattern(id, pos[0]))
{
ParsePosition ppos = new ParsePosition(pos[0]);
// Parse the set to get the position.
new UnicodeSet(id, ppos, null);
filter = id.Substring(pos[0], ppos.Index - pos[0]); // ICU4N: Corrected 2nd parameter
pos[0] = ppos.Index;
continue;
}
if (delimiter == 0)
{
char c = id[pos[0]];
if ((c == TARGET_SEP && target == null) ||
(c == VARIANT_SEP && variant == null))
{
delimiter = c;
++pos[0];
continue;
}
}
// We are about to try to parse a spec with no delimiter
// when we can no longer do so (we can only do so at the
// start); break.
if (delimiter == 0 && specCount > 0)
{
break;
}
string spec = Utility.ParseUnicodeIdentifier(id, pos);
if (spec == null)
{
// Note that if there was a trailing delimiter, we
// consume it. So Foo-, Foo/, Foo-Bar/, and Foo/Bar-
// are legal.
break;
}
switch (delimiter)
{
case (char)0:
first = spec;
break;
case TARGET_SEP:
target = spec;
break;
case VARIANT_SEP:
variant = spec;
break;
}
++specCount;
delimiter = (char)0;
}
// A spec with no prior character is either source or target,
// depending on whether an explicit "-target" was seen.
if (first != null)
{
if (target == null)
{
target = first;
}
else
{
source = first;
}
}
// Must have either source or target
if (source == null && target == null)
{
pos[0] = start;
return(null);
}
// Empty source or target defaults to ANY
bool sawSource = true;
if (source == null)
{
source = ANY;
sawSource = false;
}
if (target == null)
{
target = ANY;
}
return(new Specs(source, target, variant, sawSource, filter));
}
public void Should_throw_exception_when_given_invalid_position_input_string()
{
const string invalidPositionString = "THIS IS NOT A VALID POSITION";
var exception = Assert.Throws <CouldNotParsePositionException>(() => ParsePosition.From(invalidPositionString));
Assert.That(exception.Message, Is.EqualTo("Could not parse position from: " + invalidPositionString));
}
/// <summary>
/// Parse in tag
/// </summary>
protected ParsedToken ParseInTag()
{
_CurrentRead = null;
// Whitespaces
CharInfo c;
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
;
}
var cpos = c.Position;
// EOF ?
if (c == CharInfo.EOF)
{
_CurrentToken = null;
_State = ParseState.Content;
ResetTagBuffer();
throw new ParseError("Unexpected end of file. Tag not closed.", ReadPosition);
}
// End of auto closed tag ?
else if (c == '/' && _State == ParseState.Tag)
{
CharInfo saveSlash = c;
bool spaces = false;
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
spaces = true;
}
if (c != '>')
{
// Prepare a correct next tag
SaveChar(new CharInfo('>', (c == CharInfo.EOF) ? saveSlash.Position : c.Position));
SaveChar(saveSlash);
throw new ParseError("Invalid char after '/'. End of auto closed tag expected.", cpos);
}
if (spaces)
{
// Prepare a correct next tag
SaveChar(c);
SaveChar(saveSlash);
// Raise the error
throw new ParseError("Invalid auto closed tag, '/' need to be follow by '>'.", cpos);
}
// Returns autoclosed
var result = ParsedTag.AutoClosedTag(((ParsedTag)_CurrentToken).TagName);
result.Position = cpos;
_CurrentToken = null;
_CurrentRead = null;
_State = ParseState.Content;
ResetTagBuffer();
return(result);
}
// End of process instruction
else if (c == '?' && _State == ParseState.ProcessInstruction)
{
c = ReadChar(false);
if (c != '>')
{
throw new ParseError("Invalid char after '?'. End of process instruction expected.", cpos);
}
// Returns processinstruction
var result = ParsedTag.CloseProcessInstruction(((ParsedTag)_CurrentToken).TagName);
result.Position = cpos;
_CurrentToken = null;
_CurrentRead = null;
_State = ParseState.Content;
ResetTagBuffer();
return(result);
}
else if (c == '>')
{
// Check tag
if (_State == ParseState.ProcessInstruction)
{
throw new ParseError("A process instruction need to be closed with '?>'.", cpos);
}
// Returns close
var result = ParsedTag.CloseTag(((ParsedTag)_CurrentToken).TagName);
result.Position = cpos;
_CurrentToken = null;
_CurrentRead = null;
_State = ParseState.Content;
ResetTagBuffer();
return(result);
}
// Get the attribute name
if (!IsAttributeNameChar(c.AsChar))
{
throw new ParseError("Unexpected character.", cpos);
}
AddToCurrentRead(c);
while ((c = ReadChar(false)) != CharInfo.EOF && IsAttributeNameChar(c.AsChar))
{
AddToCurrentRead(c);
}
if (c != CharInfo.EOF)
{
SaveChar(c);
}
String attrName = GetCurrentRead(true);
ParsePosition attrPos = cpos;
// Whitespaces
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
;
}
// Attribute whithout value
if (c != '=')
{
SaveChar(c);
// Attribute whithout content
return(new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = null,
Quote = '\0'
});
}
// Whitespaces
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
;
}
// Search the value
if (c == 0 || c == '/' || c == '?' || c == '>')
{
_CurrentAttr = new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = null,
Quote = '\0'
};
if (c != CharInfo.EOF)
{
SaveChar(c);
}
throw new ParseError("Attribute value expected.", ReadPosition);
}
// Quoted value ?
_CurrentRead = null;
char quote = '\0';
if (c == '"' || c == '\'')
{
quote = c.AsChar;
while ((c = ReadChar(false)) != CharInfo.EOF && c != quote)
{
AddToCurrentRead(c);
}
_CurrentAttr = new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = HEntity.HtmlDecode(GetCurrentRead(true), RemoveUnknownOrInvalidEntities),
Quote = quote
};
if (c == CharInfo.EOF)
{
throw new ParseError("Unexpected end of file. Attribute is not closed.", ReadPosition);
}
var result = _CurrentAttr;
_CurrentAttr = null;
return(result);
}
// Unquoted value
AddToCurrentRead(c);
while ((c = ReadChar(false)) != CharInfo.EOF && !Char.IsWhiteSpace(c.AsChar) && c != '"' && c != '\'' && c != '=' && c != '<' && c != '>' && c != '`')
{
AddToCurrentRead(c);
}
SaveChar(c);
return(new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = HEntity.HtmlDecode(GetCurrentRead(true), RemoveUnknownOrInvalidEntities),
Quote = quote
});
}
/// <summary>
/// New CharInfo
/// </summary>
public CharInfo(int c, ParsePosition pos)
: this()
{
CharValue = c;
Position = pos;
}
/// <summary> /// Parse 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 object resulting from the parse, or null if there is an error</returns> public abstract Object ParseObject(String str0, ParsePosition position);
/// <summary>
/// This method is not yet supported by <c>PluralFormat</c>.
/// </summary>
///
/// <param name="text">the string to be parsed.</param>
/// <param name="parsePosition">defines the position where parsing is to begin, and uponreturn, the position where parsing left off. If the positionhas not changed upon return, then parsing failed.</param>
/// <returns>nothing because this method is not yet implemented.</returns>
/// <exception cref="UnsupportedOperationException">will always be thrown by this method.</exception>
/// @draft ICU 3.8
/// @provisional This API might change or be removed in a future release.
public object Parse(String text, ParsePosition parsePosition)
{
throw new NotSupportedException();
}
private CharacterSetParser(string input, ParsePosition position)
{
_Input = input;
_InputLength = input.Length;
_Position = position;
}
/// <summary> /// Parse a Number 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 Number resulting from the parse, or null if there is an error</returns> public abstract object Parse(String str0, ParsePosition position);
/// <summary>
/// Parse a Date 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 Date resulting from the parse, or null if there is an error</returns>
public override Object ParseObject(String str0, ParsePosition position)
{
return(Parse(str0, position));
}
public void TestBugTestsWithNamesArguments()
{
{ // Taken from Test4031438().
String pattern1 = "Impossible {arg1} has occurred -- status code is {arg0} and message is {arg2}.";
String pattern2 = "Double '' Quotes {ARG_ZERO} test and quoted '{ARG_ONE}' test plus 'other {ARG_TWO} stuff'.";
MessageFormat messageFormatter = new MessageFormat("");
try
{
Logln("Apply with pattern : " + pattern1);
messageFormatter.ApplyPattern(pattern1);
IDictionary <string, object> paramsMap = new Dictionary <string, object>();
paramsMap["arg0"] = 7;
String tempBuffer = messageFormatter.Format(paramsMap);
if (!tempBuffer.Equals("Impossible {arg1} has occurred -- status code is 7 and message is {arg2}."))
{
Errln("Tests arguments < substitution failed");
}
Logln("Formatted with 7 : " + tempBuffer);
ParsePosition status = new ParsePosition(0);
var objs = messageFormatter.ParseToMap(tempBuffer, status);
if (objs.Get("arg1") != null || objs.Get("arg2") != null)
{
Errln("Parse failed with more than expected arguments");
}
//for (Iterator keyIter = objs.keySet().iterator();
// keyIter.hasNext();)
//{
// String key = (String)keyIter.next();
foreach (var key in objs.Keys)
{
if (objs.Get(key) != null && !objs.Get(key).ToString().Equals(paramsMap.Get(key).ToString()))
{
Errln("Parse failed on object " + objs.Get(key) + " with argument name : " + key);
}
}
tempBuffer = messageFormatter.Format((object)null);
if (!tempBuffer.Equals("Impossible {arg1} has occurred -- status code is {arg0} and message is {arg2}."))
{
Errln("Tests with no arguments failed");
}
Logln("Formatted with null : " + tempBuffer);
Logln("Apply with pattern : " + pattern2);
messageFormatter.ApplyPattern(pattern2);
paramsMap.Clear();
paramsMap["ARG_ZERO"] = 7;
tempBuffer = messageFormatter.Format(paramsMap);
if (!tempBuffer.Equals("Double ' Quotes 7 test and quoted {ARG_ONE} test plus 'other {ARG_TWO} stuff'."))
{
Errln("quote format test (w/ params) failed.");
}
Logln("Formatted with params : " + tempBuffer);
tempBuffer = messageFormatter.Format((object)null);
if (!tempBuffer.Equals("Double ' Quotes {ARG_ZERO} test and quoted {ARG_ONE} test plus 'other {ARG_TWO} stuff'."))
{
Errln("quote format test (w/ null) failed.");
}
Logln("Formatted with null : " + tempBuffer);
Logln("toPattern : " + messageFormatter.ToPattern());
}
catch (Exception foo)
{
Warnln("Exception when formatting in bug 4031438. " + foo.Message);
}
}
{ // Taken from Test4052223().
ParsePosition pos = new ParsePosition(0);
if (pos.ErrorIndex != -1)
{
Errln("ParsePosition.getErrorIndex initialization failed.");
}
MessageFormat fmt = new MessageFormat("There are {numberOfApples} apples growing on the {whatKindOfTree} tree.");
String str = "There is one apple growing on the peach tree.";
var objs = fmt.ParseToMap(str, pos);
Logln("unparsable string , should fail at " + pos.ErrorIndex);
if (pos.ErrorIndex == -1)
{
Errln("Bug 4052223 failed : parsing string " + str);
}
pos.ErrorIndex = (4);
if (pos.ErrorIndex != 4)
{
Errln("setErrorIndex failed, got " + pos.ErrorIndex + " instead of 4");
}
if (objs != null)
{
Errln("unparsable string, should return null");
}
}
// ICU4N TODO: Serialization
//{ // Taken from Test4111739().
// MessageFormat format1 = null;
// MessageFormat format2 = null;
// ObjectOutputStream ostream = null;
// ByteArrayOutputStream baos = null;
// ObjectInputStream istream = null;
// try
// {
// baos = new ByteArrayOutputStream();
// ostream = new ObjectOutputStream(baos);
// }
// catch (IOException e)
// {
// Errln("Unexpected exception : " + e.getMessage());
// return;
// }
// try
// {
// format1 = new MessageFormat("pattern{argument}");
// ostream.writeObject(format1);
// ostream.flush();
// byte bytes[] = baos.toByteArray();
// istream = new ObjectInputStream(new ByteArrayInputStream(bytes));
// format2 = (MessageFormat)istream.readObject();
// }
// catch (Exception e)
// {
// Errln("Unexpected exception : " + e.Message);
// }
// if (!format1.Equals(format2))
// {
// Errln("MessageFormats before and after serialization are not" +
// " equal\nformat1 = " + format1 + "(" + format1.ToPattern() + ")\nformat2 = " +
// format2 + "(" + format2.ToPattern() + ")");
// }
// else
// {
// Logln("Serialization for MessageFormat is OK.");
// }
//}
{ // Taken from Test4116444().
String[] patterns = { "", "one", "{namedArgument,date,short}" };
MessageFormat mf = new MessageFormat("");
for (int i = 0; i < patterns.Length; i++)
{
String pattern = patterns[i];
mf.ApplyPattern(pattern);
try
{
var objs = mf.ParseToMap(null, new ParsePosition(0));
Logln("pattern: \"" + pattern + "\"");
Log(" parsedObjects: ");
if (objs != null)
{
Log("{");
//for (Iterator keyIter = objs.keySet().iterator();
// keyIter.hasNext();)
//{
// String key = (String)keyIter.next();
bool first = true;
foreach (var key in objs.Keys)
{
if (first)
{
first = false;
}
else
{
Log(",");
}
if (objs.Get(key) != null)
{
Err("\"" + objs.Get(key).ToString() + "\"");
}
else
{
Log("null");
}
//if (keyIter.hasNext())
//{
// Log(",");
//}
}
Log("}");
}
else
{
Log("null");
}
Logln("");
}
catch (Exception e)
{
Errln("pattern: \"" + pattern + "\"");
Errln(" Exception: " + e.Message);
}
}
}
{ // Taken from Test4114739().
MessageFormat mf = new MessageFormat("<{arg}>");
IDictionary <string, object> objs1 = null;
IDictionary <string, object> objs2 = new Dictionary <string, object>();
IDictionary <string, object> objs3 = new Dictionary <string, object>();
objs3["arg"] = null;
try
{
Logln("pattern: \"" + mf.ToPattern() + "\"");
Log("format(null) : ");
Logln("\"" + mf.Format(objs1) + "\"");
Log("format({}) : ");
Logln("\"" + mf.Format(objs2) + "\"");
Log("format({null}) :");
Logln("\"" + mf.Format(objs3) + "\"");
}
catch (Exception e)
{
Errln("Exception thrown for null argument tests.");
}
}
{ // Taken from Test4118594().
String argName = "something_stupid";
MessageFormat mf = new MessageFormat("{" + argName + "}, {" + argName + "}, {" + argName + "}");
String forParsing = "x, y, z";
var objs = mf.ParseToMap(forParsing, new ParsePosition(0));
Logln("pattern: \"" + mf.ToPattern() + "\"");
Logln("text for parsing: \"" + forParsing + "\"");
if (!objs.Get(argName).ToString().Equals("z"))
{
Errln("argument0: \"" + objs.Get(argName) + "\"");
}
mf.SetLocale(new CultureInfo("en-us"));
mf.ApplyPattern("{" + argName + ",number,#.##}, {" + argName + ",number,#.#}");
var oldobjs = new Dictionary <string, object>();
oldobjs[argName] = 3.1415d;
String result = mf.Format(oldobjs);
Logln("pattern: \"" + mf.ToPattern() + "\"");
Logln("text for parsing: \"" + result + "\"");
// result now equals "3.14, 3.1"
if (!result.Equals("3.14, 3.1"))
{
Errln("result = " + result);
}
var newobjs = mf.ParseToMap(result, new ParsePosition(0));
// newobjs now equals {new Double(3.1)}
if (Convert.ToDouble(newobjs.Get(argName)) != 3.1) // was (Double) [alan]
{
Errln("newobjs.get(argName) = " + newobjs.Get(argName));
}
}
{ // Taken from Test4105380().
String patternText1 = "The disk \"{diskName}\" contains {numberOfFiles}.";
String patternText2 = "There are {numberOfFiles} on the disk \"{diskName}\"";
MessageFormat form1 = new MessageFormat(patternText1);
MessageFormat form2 = new MessageFormat(patternText2);
double[] filelimits = { 0, 1, 2 };
String[] filepart = { "no files", "one file", "{numberOfFiles,number} files" };
ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
form1.SetFormat(1, fileform);
form2.SetFormat(0, fileform);
var testArgs = new Dictionary <string, object>();
testArgs["diskName"] = "MyDisk";
testArgs["numberOfFiles"] = 12373L;
Logln(form1.Format(testArgs));
Logln(form2.Format(testArgs));
}
{ // Taken from test4293229().
MessageFormat format = new MessageFormat("'''{'myNamedArgument}'' '''{myNamedArgument}'''");
var args = new Dictionary <string, object>();
String expected = "'{myNamedArgument}' '{myNamedArgument}'";
String result = format.Format(args);
if (!result.Equals(expected))
{
throw new Exception("wrong format result - expected \"" +
expected + "\", got \"" + result + "\"");
}
}
}
/// <summary>
/// This method is not yet supported by <see cref="PluralFormat"/>.
/// </summary>
/// <param name="text">the string to be parsed.</param>
/// <param name="parsePosition">defines the position where parsing is to begin,
/// and upon return, the position where parsing left off. If the position
/// has not changed upon return, then parsing failed.</param>
/// <returns>nothing because this method is not yet implemented.</returns>
/// <exception cref="InvalidOperationException">will always be thrown by this method.</exception>
/// <stable>ICU 3.8</stable>
public virtual /*Number*/ object Parse(string text, ParsePosition parsePosition)
{
// You get number ranges from this. You can't get an exact number.
throw new InvalidOperationException();
}
/// <summary>
/// Parse a global filter of the form "[f]" or "([f])", depending
/// on <paramref name="withParens"/>.
/// </summary>
/// <param name="id">The pattern to parse.</param>
/// <param name="pos">INPUT-OUTPUT parameter. On input, the position of
/// the first character to parse. On output, the position after
/// the last character parsed.</param>
/// <param name="dir">The direction.</param>
/// <param name="withParens">INPUT-OUTPUT parameter. On entry, if
/// withParens[0] is 0, then parens are disallowed. If it is 1,
/// then parens are requires. If it is -1, then parens are
/// optional, and the return result will be set to 0 or 1.</param>
/// <param name="canonID">OUTPUT parameter. The pattern for the filter
/// added to the canonID, either at the end, if dir is <see cref="TransliterationDirection.Forward"/>, or
/// at the start, if dir is <see cref="TransliterationDirection.Reverse"/>. The pattern will be enclosed
/// in parentheses if appropriate, and will be suffixed with an
/// <see cref="ID_DELIM"/> character. May be null.</param>
/// <returns>A <see cref="UnicodeSet"/> object or null. A non-null results
/// indicates a successful parse, regardless of whether the filter
/// applies to the given direction. The caller should discard it
/// if withParens != (dir == <see cref="TransliterationDirection.Reverse"/>).</returns>
public static UnicodeSet ParseGlobalFilter(string id, int[] pos, TransliterationDirection dir,
int[] withParens,
StringBuffer canonID)
{
UnicodeSet filter = null;
int start = pos[0];
if (withParens[0] == -1)
{
withParens[0] = Utility.ParseChar(id, pos, OPEN_REV) ? 1 : 0;
}
else if (withParens[0] == 1)
{
if (!Utility.ParseChar(id, pos, OPEN_REV))
{
pos[0] = start;
return(null);
}
}
pos[0] = PatternProps.SkipWhiteSpace(id, pos[0]);
if (UnicodeSet.ResemblesPattern(id, pos[0]))
{
ParsePosition ppos = new ParsePosition(pos[0]);
try
{
filter = new UnicodeSet(id, ppos, null);
}
catch (ArgumentException)
{
pos[0] = start;
return(null);
}
string pattern = id.Substring(pos[0], ppos.Index - pos[0]); // ICU4N: Corrected 2nd parameter
pos[0] = ppos.Index;
if (withParens[0] == 1 && !Utility.ParseChar(id, pos, CLOSE_REV))
{
pos[0] = start;
return(null);
}
// In the forward direction, append the pattern to the
// canonID. In the reverse, insert it at zero, and invert
// the presence of parens ("A" <-> "(A)").
if (canonID != null)
{
if (dir == Forward)
{
if (withParens[0] == 1)
{
pattern = OPEN_REV + pattern + CLOSE_REV;
}
canonID.Append(pattern + ID_DELIM);
}
else
{
if (withParens[0] == 0)
{
pattern = OPEN_REV + pattern + CLOSE_REV;
}
canonID.Insert(0, pattern + ID_DELIM);
}
}
}
return(filter);
}
/// <summary>
/// This method is not yet supported by <see cref="PluralFormat"/>.
/// </summary>
/// <param name="source">the string to be parsed.</param>
/// <param name="pos">defines the position where parsing is to begin,
/// and upon return, the position where parsing left off. If the position
/// has not changed upon return, then parsing failed.</param>
/// <returns>nothing because this method is not yet implemented.</returns>
/// <exception cref="InvalidOperationException">will always be thrown by this method.</exception>
/// <stable>ICU 3.8</stable>
public override object ParseObject(String source, ParsePosition pos)
{
throw new InvalidOperationException();
}
public override Number Parse(string @string, ParsePosition position)
{
return null;
}
/// <summary>
/// Override Format.parseObject().
/// </summary>
///
/// <seealso cref="M:ILOG.J2CsMapping.Text.IlFormat.ParseObject(System.String, IBM.ICU.Text.ParsePosition)"/>
public override Object ParseObject(String source, ParsePosition pos)
{
return(fmt.ParseCurrency(source, pos));
}
///
/// <summary>
/// This method is not supported by <see cref="SelectFormat"/>.
/// </summary>
/// <param name="source">the string to be parsed.</param>
/// <param name="pos">defines the position where parsing is to begin,
/// and upon return, the position where parsing left off. If the position
/// has not changed upon return, then parsing failed.</param>
/// <returns>nothing because this method is not supported.</returns>
/// <exception cref="NotSupportedException">thrown always.</exception>
/// <stable>ICU 4.4</stable>
public override object ParseObject(string source, ParsePosition pos)
{
throw new NotSupportedException();
}
/// <summary>
/// Parse a Date 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 according to the pattern of thisSimpleDateFormat</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 Date resulting from the parse, or null if there is an error</returns>
/// <exception cref="IllegalArgumentException">when there are invalid characters in the pattern</exception>
public override DateTime Parse(String str0, ParsePosition position)
{
icuFormat.SetTimeZone(IBM.ICU.Util.TimeZone.GetTimeZone(calendar
.GetTimeZone().GetID()));
return(icuFormat.Parse(str0, position));
}
