/// <summary>
/// Separates the variants by type.
/// Intended for use with plural and select argument styles,
/// not useful for choice argument styles.
/// <para/>
/// Both parameters are used only for output, and are first cleared.
/// </summary>
/// <param name="numericVariants">Variants with numeric-value selectors (if any) are added here.
/// Can be null for a select argument style.</param>
/// <param name="keywordVariants">Variants with keyword selectors, except "other", are added here.
/// For a plural argument, if this list is empty after the call, then
/// all variants except "other" have explicit values
/// and PluralRules need not be called.</param>
/// <returns>the "other" variant (the first one if there are several),
/// null if none (choice style)</returns>
/// <stable>ICU 49</stable>
public virtual VariantNode GetVariantsByType(IList <VariantNode> numericVariants,
IList <VariantNode> keywordVariants)
{
if (numericVariants != null)
{
numericVariants.Clear();
}
keywordVariants.Clear();
VariantNode other = null;
foreach (VariantNode variant in list)
{
if (variant.IsSelectorNumeric)
{
numericVariants.Add(variant);
}
else if ("other".Equals(variant.Selector))
{
if (other == null)
{
// Return the first "other" variant. (MessagePattern allows duplicates.)
other = variant;
}
}
else
{
keywordVariants.Add(variant);
}
}
return(other);
}
private static ComplexArgStyleNode BuildPluralStyleNode(MessagePattern pattern,
int start, int limit,
MessagePatternArgType argType)
{
ComplexArgStyleNode node = new ComplexArgStyleNode(argType);
MessagePatternPart offset = pattern.GetPart(start);
if (offset.Type.HasNumericValue())
{
node.HasExplicitOffset = true;
node.Offset = pattern.GetNumericValue(offset);
++start;
}
while (start < limit)
{
MessagePatternPart selector = pattern.GetPart(start++);
double value = MessagePattern.NoNumericValue;
MessagePatternPart part = pattern.GetPart(start);
if (part.Type.HasNumericValue())
{
value = pattern.GetNumericValue(part);
++start;
}
int msgLimit = pattern.GetLimitPartIndex(start);
VariantNode variant = new VariantNode();
variant.Selector = pattern.GetSubstring(selector);
variant.SelectorValue = value;
variant.Message = BuildMessageNode(pattern, start, msgLimit);
node.AddVariant(variant);
start = msgLimit + 1;
}
return(node.Freeze());
}
internal bool Matches(VariantNode v)
{
bool ok = assertEquals("different selector strings",
selector, v.Selector);
ok &= assertEquals("different selector strings",
IsSelectorNumeric(), v.IsSelectorNumeric);
ok &= assertEquals("different selector strings",
numericValue, v.SelectorValue);
return(ok & msg.Matches(v.Message));
}
public void TestPluralVariantsByType()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"{p,plural,a{A}other{O}=4{iv}b{B}other{U}=2{ii}}");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectPluralArg("p").
ExpectVariant("a").ExpectTextThatContains("A").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("O").FinishVariant().
ExpectVariant("=4", 4).ExpectTextThatContains("iv").FinishVariant().
ExpectVariant("b").ExpectTextThatContains("B").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("U").FinishVariant().
ExpectVariant("=2", 2).ExpectTextThatContains("ii").FinishVariant().
finishComplexArg();
if (!expect.Matches(msg))
{
return;
}
List <VariantNode> numericVariants = new List <VariantNode>();
List <VariantNode> keywordVariants = new List <VariantNode>();
VariantNode other =
((ArgNode)msg.GetContents()[0]).ComplexStyle.
GetVariantsByType(numericVariants, keywordVariants);
assertEquals("'other' selector", "other", other.Selector);
assertEquals("message string of first 'other'", "O", VariantText(other));
assertEquals("numericVariants.size()", 2, numericVariants.Count);
VariantNode v = numericVariants[0];
assertEquals("numericVariants[0] selector", "=4", v.Selector);
assertEquals("numericVariants[0] selector value", 4.0, v.SelectorValue);
assertEquals("numericVariants[0] text", "iv", VariantText(v));
v = numericVariants[1];
assertEquals("numericVariants[1] selector", "=2", v.Selector);
assertEquals("numericVariants[1] selector value", 2.0, v.SelectorValue);
assertEquals("numericVariants[1] text", "ii", VariantText(v));
assertEquals("keywordVariants.size()", 2, keywordVariants.Count);
v = keywordVariants[0];
assertEquals("keywordVariants[0] selector", "a", v.Selector);
assertFalse("keywordVariants[0].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[0] text", "A", VariantText(v));
v = keywordVariants[1];
assertEquals("keywordVariants[1] selector", "b", v.Selector);
assertFalse("keywordVariants[1].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[1] text", "B", VariantText(v));
}
private static ComplexArgStyleNode BuildSelectStyleNode(MessagePattern pattern,
int start, int limit)
{
ComplexArgStyleNode node = new ComplexArgStyleNode(MessagePatternArgType.Select);
while (start < limit)
{
MessagePatternPart selector = pattern.GetPart(start++);
int msgLimit = pattern.GetLimitPartIndex(start);
VariantNode variant = new VariantNode();
variant.Selector = pattern.GetSubstring(selector);
variant.Message = BuildMessageNode(pattern, start, msgLimit);
node.AddVariant(variant);
start = msgLimit + 1;
}
return(node.Freeze());
}
private static ComplexArgStyleNode BuildChoiceStyleNode(MessagePattern pattern,
int start, int limit)
{
ComplexArgStyleNode node = new ComplexArgStyleNode(MessagePatternArgType.Choice);
while (start < limit)
{
int valueIndex = start;
MessagePatternPart part = pattern.GetPart(start);
double value = pattern.GetNumericValue(part);
start += 2;
int msgLimit = pattern.GetLimitPartIndex(start);
VariantNode variant = new VariantNode();
variant.Selector = pattern.GetSubstring(pattern.GetPart(valueIndex + 1));
variant.SelectorValue = value;
variant.Message = BuildMessageNode(pattern, start, msgLimit);
node.AddVariant(variant);
start = msgLimit + 1;
}
return(node.Freeze());
}
public void TestSelectVariantsByType()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"{s,select,a{A}other{O}b{B}other{U}}");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectSelectArg("s").
ExpectVariant("a").ExpectTextThatContains("A").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("O").FinishVariant().
ExpectVariant("b").ExpectTextThatContains("B").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("U").FinishVariant().
finishComplexArg();
if (!expect.Matches(msg))
{
return;
}
// Check that we can use numericVariants = null.
IList <VariantNode> keywordVariants = new List <VariantNode>();
VariantNode other =
((ArgNode)msg.GetContents()[0]).ComplexStyle.
GetVariantsByType(null, keywordVariants);
assertEquals("'other' selector", "other", other.Selector);
assertEquals("message string of first 'other'", "O", VariantText(other));
assertEquals("keywordVariants.size()", 2, keywordVariants.Count);
VariantNode v = keywordVariants[0];
assertEquals("keywordVariants[0] selector", "a", v.Selector);
assertFalse("keywordVariants[0].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[0] text", "A", VariantText(v));
v = keywordVariants[1];
assertEquals("keywordVariants[1] selector", "b", v.Selector);
assertFalse("keywordVariants[1].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[1] text", "B", VariantText(v));
}
internal void AddVariant(VariantNode variant)
{
list.Add(variant);
}
/**
* @return the text string of the VariantNode's message;
* assumes that its message consists of only text
*/
private String VariantText(VariantNode v)
{
return(((TextNode)v.Message.GetContents()[0]).Text);
}
