/// <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); }