private CharMatcher GetMatcher(char ky)
{
CharMatcher matcher = null;
this.Dictionary.TryGetValue(char.ToLower(ky), out matcher);
return(matcher);
}
static EmojiParser()
{
Parser = new EmojiParser();
var emojiTexts = "/:^_^,/:^$^,/:q,/:815,/:809,/:^o^,/:081,/:087,/:086,/:h,/:012,/:806,/:b,/:^x^,/:814,/:^w^,/:080,/:066,/:807,/:805,/:071,/:072,/:065,/:804,/:813,/:818,/:015,/:084,/:801,/:811,/:?,/:077,/:083,/:817,/:!,/:068,/:079,/:028,/:026,/:007,/:816,/:'\"\",/:802,/:027,/:(zz...),/:*&*,/:810,/:>_<,/:018,/:>o<,/:020,/:044,/:819,/:085,/:812,/:\",/:>m<,/:>@<,/:076,/:069,/:o,/:067,/:043,/:p,/:808,/:>w<,/:073,/:008,/:803,/:074,/:o=o,/:036,/:039,/:045,/:046,/:048,/:047,/:girl,/:man,/:052,/:(ok),/:8*8 ,/:)-(,/:lip,/:-f,/:-w,/:y,/:qp,/:$,/:%,/:(&),/:@,/:~b,/:u* u,/:clock,/:r,/:c,/:plane,/:075".xSplitByComma(StringSplitOptions.RemoveEmptyEntries);
int maxLen = 0;
int minLen = int.MaxValue;
foreach (var emt in emojiTexts)
{
if (emt.Length > maxLen)
{
maxLen = emt.Length;
}
if (emt.Length < minLen)
{
minLen = emt.Length;
}
}
MaxPhizLength = maxLen;
MinPhizLength = minLen;
_emojiSet = new HashSet <string>(emojiTexts);
for (int j = 0; j < emojiTexts.Length; j++)
{
emojiTexts[j] = emojiTexts[j].Substring(2);
}
_matcher = CharMatcher.Create(emojiTexts.ToList());
}
public void ForPredicateTest()
{
CharMatcher.IsNot('m').ForPredicate(c => c == 'm').ShouldBeEmpty();
CharMatcher.IsNot('m').ForPredicate(c => c == 'n').ShouldBe("m");
CharMatcher.IsNot('m').Negate().ForPredicate(c => c == 'm').ShouldBe("m");
CharMatcher.IsNot('m').Negate().ForPredicate(c => c == 'n').ShouldBeEmpty();
}
public void MatchesAllOfTest()
{
CharMatcher.IsNot('m').MatchesAllOf("Nice to meet you").ShouldBeTrue();
CharMatcher.IsNot('m').MatchesAllOf("mmmmmmmmmmmmmmmmm").ShouldBeFalse();
CharMatcher.IsNot('m').Negate().MatchesAllOf("Nice to meet you").ShouldBeFalse();
CharMatcher.IsNot('m').Negate().MatchesAllOf("mmmmmmmmmmmmmmmmm").ShouldBeTrue();
}
// STATIC CONSTRUCTOR
static DMMLoader()
{
// A-Za-z0-9_/
ATOM_NAME_CHARS = CharRange.Build('A', 'Z') | CharRange.Build('a', 'z') | CharRange.Build('0', '9') | "_/";
WHITESPACE = new ConstCharMatcher("\r\n");
REGEX_FLOAT = new Regex(@"^[0-9\.]+([Ee][\+\-][0-9]+)?$");
REGEX_INTEGER = new Regex(@"^\d+$");
}
public void ReplaceFromTest()
{
CharMatcher.IsNot('m').ReplaceFrom("Nice to meet you", 'n').ShouldBe("nnnnnnnnmnnnnnnn");
CharMatcher.IsNot('m').ReplaceFrom("Nice to meet you", "__").ShouldBe("________________m______________");
CharMatcher.IsNot('m').Negate().ReplaceFrom("Nice to meet you", 'n').ShouldBe("Nice to neet you");
CharMatcher.IsNot('m').Negate().ReplaceFrom("Nice to meet you", "__").ShouldBe("Nice to __eet you");
}
/// <summary>
/// Creates an instance, validating the name against a matcher.
/// <para>
/// In most cases, a <seealso cref="CharMatcher"/> will be faster than a regex <seealso cref="Pattern"/>,
/// typically by over an order of magnitude.
///
/// </para>
/// </summary>
/// <param name="name"> the name, not empty </param>
/// <param name="matcher"> the matcher for validating the name </param>
/// <param name="msg"> the message to use to explain validation failure </param>
protected internal TypedString(string name, CharMatcher matcher, string msg)
{
ArgChecker.notEmpty(name, "name");
ArgChecker.notNull(matcher, "pattern");
ArgChecker.notEmpty(msg, "msg");
if (matcher.matchesAllOf(name) == false)
{
throw new System.ArgumentException(msg);
}
this.name = name;
}
public void TestPatternSplitWithTrim()
{
const string jacksons = "arfo(Marlon)aorf, (Michael)orfa, afro(Jackie)orfa, "
+ "ofar(Jemaine), aff(Tito)";
var family = Splitter.On(new Regex(","))
.TrimResults(CharMatcher.anyOf("afro").Or(CharMatcher.Whitespace))
.split(jacksons);
family.Should()
.ContainExactlyInOrder("(Marlon)", "(Michael)", "(Jackie)", "(Jemaine)", "(Tito)");
}
public void TestFallback()
{
ITokenMatcher matcher1 = new CharMatcher('(');
ITokenMatcher matcher2 = new CharMatcher(')');
ITokenMatcher matcher3 = new StringMatcher("(test)");
ITokenMatcher matcher4 = new AnyCharMatcher("abcdefghijklmnopqrstuvwxyz");
Tokenizer tokenizer = new Tokenizer();
tokenizer.AddTokenMatcher(matcher1);
tokenizer.AddTokenMatcher(matcher2);
tokenizer.AddTokenMatcher(matcher3);
tokenizer.AddTokenMatcher(matcher4);
Token[] tokens = tokenizer.Tokenize("(test)(x)");
Assert.AreEqual(4, tokens.Length);
}
public static CharMatcher Create(List <string> emojiTexts)
{
Util.Assert(emojiTexts.xCount <string>() > 0);
var matcher = new CharMatcher();
emojiTexts.xSortStringByAsciiAsc();
while (emojiTexts.Count > 0)
{
if (emojiTexts.First() == "")
{
matcher.Dictionary['\0'] = null;
int idx = emojiTexts.FindIndex(k => !string.IsNullOrEmpty(k));
if (idx == -1)
{
idx = emojiTexts.Count;
}
emojiTexts.RemoveRange(0, idx);
}
else
{
char ch = emojiTexts[0][0];
int idx = emojiTexts.FindIndex(k => k[0] != ch);
if (idx == -1)
{
idx = emojiTexts.Count;
}
var emojits = emojiTexts.xCopy(0, idx);
for (int i = 0; i < emojits.Count; i++)
{
emojits[i] = emojits[i].Substring(1);
}
matcher.Dictionary[ch] = CharMatcher.Create(emojits);
emojiTexts.RemoveRange(0, idx);
}
}
return(matcher);
}
public void TrimLeadingFormTest()
{
CharMatcher.IsNot('m').TrimLeadingForm("Nice to meet you").ShouldBeEmpty();
CharMatcher.IsNot('N').TrimLeadingForm("Nice to meet you").ShouldBe("N");
CharMatcher.IsNot('u').TrimLeadingForm("Nice to meet you").ShouldBeEmpty();
}
public void LastIndexInTest()
{
CharMatcher.IsNot('m').LastIndexIn("Nice to meet you").ShouldBe(8);
CharMatcher.IsNot('m').Negate().LastIndexIn("Nice to meet you").ShouldBe(8);
}
public void TrimFromTest()
{
CharMatcher.IsNot('m').TrimFrom("Nice to meet you").ShouldBeEmpty();
CharMatcher.IsNot('N').TrimFrom("Nice to meet you").ShouldBe("NN");
CharMatcher.IsNot('u').TrimFrom("Nice to meet you").ShouldBe("uu");
}
public void RetainFromTest()
{
CharMatcher.IsNot('m').RetainFrom("Nice to meet you").ShouldBe("Nice to eet you");
CharMatcher.IsNot('m').Negate().RetainFrom("Nice to meet you").ShouldBe("m");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = ".*'name'.*") public void test_matches_CharMatcher_String_nullString()
public virtual void test_matches_CharMatcher_String_nullString()
{
ArgChecker.matches(CharMatcher.inRange('A', 'Z'), 1, 2, null, "name", "[A-Z]+");
}
public void InRangeTest()
{
CharMatcher.IsNot('m').InRange('l', 'n').ShouldBeEmpty();
CharMatcher.IsNot('m').InRange('o', 'q').ShouldBe("m");
}
public void IndexInTest()
{
CharMatcher.IsNot('m').IndexIn("Nice to meet you").ShouldBe(8);
CharMatcher.IsNot('m').IndexIn("Nice to meet you", 5).ShouldBe(8);
CharMatcher.IsNot('m').IndexIn("Nice to meet you", 9).ShouldBe(-1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = ".*'name'.*'123'.*") public void test_matches_CharMatcher_String_noMatch()
public virtual void test_matches_CharMatcher_String_noMatch()
{
ArgChecker.matches(CharMatcher.inRange('A', 'Z'), 1, int.MaxValue, "123", "name", "[A-Z]+");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = ".*'name'.*") public void test_matches_CharMatcher_String_tooShort()
public virtual void test_matches_CharMatcher_String_tooShort()
{
ArgChecker.matches(CharMatcher.inRange('A', 'Z'), 1, 2, "", "name", "[A-Z]+");
}
public void ApplyTest()
{
CharMatcher.IsNot('m').Apply('m').ShouldBeFalse();
CharMatcher.IsNot('m').Negate().Apply('m').ShouldBeTrue();
}
public void TrimFromTest()
{
CharMatcher.Is('m').TrimFrom("Nice to meet you").ShouldBe("Nice to meet you");
CharMatcher.Is('N').TrimFrom("Nice to meet you").ShouldBe("ice to meet you");
CharMatcher.Is('u').TrimFrom("Nice to meet you").ShouldBe("Nice to meet yo");
}
public void TrimAndCollapseFromTest()
{
CharMatcher.Is('m').TrimAndCollapseFrom("Nice to meet you", 'y').ShouldBe("Nice to yeet you");
CharMatcher.Is('N').TrimAndCollapseFrom("Nice to meet you", 'y').ShouldBe("ice to meet you");
CharMatcher.Is('u').TrimAndCollapseFrom("Nice to meet you", 'y').ShouldBe("Nice to meet yo");
}
public void CollapseFromTest()
{
CharMatcher.IsNot('m').CollapseFrom("Nice to meet you", 'y').ShouldBe("yyyyyyyymyyyyyyy");
CharMatcher.IsNot('m').Negate().CollapseFrom("Nice to meet you", 'y').ShouldBe("Nice to yeet you");
}
public void CountInTest()
{
CharMatcher.IsNot('m').CountIn("Nice to meet you").ShouldBe(1);
CharMatcher.IsNot('m').Negate().CountIn("Nice to meet you").ShouldBe(1);
}
static MappingTokenizer()
{
var nameChars = CharMatcher.AnyOf(
CharMatcher.Range('a', 'z'),
CharMatcher.Range('A', 'Z'),
CharMatcher.Range('0', '9'),
CharMatcher.AnyOf('_', '-'));
var newLineChars = CharMatcher.AnyOf('\r', '\n');
var whitespaceChars = CharMatcher.AnyOf(' ', '\t');
Tokeniser = new Tokenizer <TokenType>(TokenType.String)
.Token(
TokenType.Comment,
o => o
.Match(CharMatcher.Single('/')).CanStart()
.Then(CharMatcher.Single('/'))
.Then(CharMatcher.NoneOf(newLineChars)).CanRepeat().CanEnd())
.Token(
TokenType.Comment,
o =>
{
var commentContent = o
.Match(CharMatcher.Single('/')).CanStart()
.Then(CharMatcher.Single('*'))
.Then(CharMatcher.NoneOf('*')).CanRepeat();
var closingStar = commentContent
.Then(CharMatcher.Single('*')).CanRepeat();
closingStar
.Then(CharMatcher.Single('/')).CanEnd();
closingStar.CanFollowWith(commentContent);
})
.Token(
TokenType.QuotedItem,
o =>
{
var start = o.Match(CharMatcher.Single('"')).CanStart();
var end = start
.Then(CharMatcher.NoneOf('"')).CanRepeat()
.Then(CharMatcher.Single('"')).CanEnd();
end.CanFollowWith(start);
start.CanFollowWith(end);
})
.Token(
TokenType.Partial,
o => o
.Match(CharMatcher.Single('<')).CanStart()
.Then(CharMatcher.Single('<'))
.Then(nameChars).CanRepeat()
.Then(CharMatcher.Single('>'))
.Then(CharMatcher.Single('>')).CanEnd())
.Token(
TokenType.Variable,
o => o
.Match(CharMatcher.Single('$')).CanStart()
.Then(CharMatcher.Single('('))
.Then(nameChars).CanRepeat()
.Then(CharMatcher.Single(')')).CanEnd())
.Token(
TokenType.LineContinuation,
o =>
{
var start = o.Match(newLineChars).CanRepeat().CanStart();
var end = o.Match(whitespaceChars).CanRepeat().CanEnd();
start.CanFollowWith(end);
end.CanFollowWith(start);
})
.Token(
TokenType.NewLine,
o => o.Match(newLineChars).CanStart().CanRepeat().CanEnd())
.Token(
TokenType.Whitespace,
o => o.Match(whitespaceChars).CanStart().CanRepeat().CanEnd())
.Token(TokenType.PartialAssignment, "::")
.Token(TokenType.And, "&&")
.Token(TokenType.Or, "||")
.Token(TokenType.Equals, '=')
.Token(TokenType.Dot, '.')
.Token(TokenType.Array, "[]")
.Token(TokenType.OpenSquareBracket, '[')
.Token(TokenType.CloseSquareBracket, ']')
.Token(TokenType.OpenCurlyBracket, '{')
.Token(TokenType.CloseCurlyBracket, '}')
.Token(TokenType.Comma, ',')
.Token(TokenType.QuestionMark, '?')
.Token(TokenType.ExclaimationMark, '!')
.Token(TokenType.OpenRoundBracket, '(')
.Token(TokenType.CloseRoundBracket, ')')
.Token(TokenType.Colon, ":")
.Token(
TokenType.Item,
o => o.Match(nameChars).CanStart().CanRepeat().CanEnd())
.Token(TokenType.WildCard, '*');
}
//-------------------------------------------------------------------------
public virtual void test_matches_CharMatcher_String_ok()
{
assertEquals(ArgChecker.matches(CharMatcher.inRange('A', 'Z'), 1, int.MaxValue, "OG", "name", "[A-Z]+"), "OG");
}
