public PatternEntry(string pattern, string pattern2, string pattern3, FlagValue condition, FlagValue condition2)
{
Pattern = pattern ?? string.Empty;
Pattern2 = pattern2 ?? string.Empty;
Pattern3 = pattern3 ?? string.Empty;
Condition = condition;
Condition2 = condition2;
}
private bool TryParseFlag(StringSlice text, out FlagValue value)
{
var flagMode = Builder.FlagMode;
if (flagMode == FlagMode.Uni)
{
text = ReDecodeConvertedStringAsUtf8(text);
flagMode = FlagMode.Char;
}
return(FlagValue.TryParseFlag(text, flagMode, out value));
}
private FlagValue[] ParseFlagsInOrder(StringSlice text)
{
var flagMode = Builder.FlagMode;
if (flagMode == FlagMode.Uni)
{
text = ReDecodeConvertedStringAsUtf8(text);
flagMode = FlagMode.Char;
}
return(FlagValue.ParseFlagsInOrder(text, flagMode));
}
public bool ContainsAnyContClass(FlagValue a, FlagValue b) => AffixEntry.ContainsAnyContClass(a, b);
public bool ContainsContClass(FlagValue value) => AffixEntry.ContainsContClass(value);
public AffixEntryGroup <TEntry> GetByFlag(FlagValue flag)
{
AffixesByFlag.TryGetValue(flag, out AffixEntryGroup <TEntry> result);
return(result);
}
public bool ContainsAnyContClass(FlagValue a, FlagValue b, FlagValue c) => ContClass.ContainsAny(a, b, c);
public bool ContainsAnyContClass(FlagValue a, FlagValue b) => ContClass.ContainsAny(a, b);
public bool ContainsContClass(FlagValue flag) => ContClass.Contains(flag);
public AffixEntryGroup(FlagValue aFlag, AffixEntryOptions options, AffixEntryCollection <TEntry> entries)
{
AFlag = aFlag;
Options = options;
Entries = entries;
}
private bool ParseLine(string line)
{
if (string.IsNullOrEmpty(line))
{
return(true);
}
if (!hasInitialized && AttemptToProcessInitializationLine(line))
{
return(true);
}
if (Builder.EntriesByRoot == null)
{
Builder.InitializeEntriesByRoot(-1);
}
var parsed = ParsedWordLine.Parse(line);
if (string.IsNullOrEmpty(parsed.Word))
{
return(false);
}
FlagSet flags;
if (!string.IsNullOrEmpty(parsed.Flags))
{
if (Affix.IsAliasF)
{
if (IntEx.TryParseInvariant(parsed.Flags, out int flagAliasNumber) && Affix.TryGetAliasF(flagAliasNumber, out FlagSet aliasedFlags))
{
flags = aliasedFlags;
}
else
{
// TODO: warn
return(false);
}
}
else if (Affix.FlagMode == FlagMode.Uni)
{
var encodedBytes = Affix.Encoding.GetBytes(parsed.Flags);
var utf8Flags = Encoding.UTF8.GetString(encodedBytes, 0, encodedBytes.Length);
flags = Builder.Dedup(FlagValue.ParseFlags(utf8Flags, FlagMode.Char));
}
else
{
flags = Builder.Dedup(FlagValue.ParseFlags(parsed.Flags, Affix.FlagMode));
}
}
else
{
flags = FlagSet.Empty;
}
MorphSet morphs;
if (parsed.Morphs != null && parsed.Morphs.Length != 0)
{
var morphValues = new string[parsed.Morphs.Length];
for (int i = 0; i < parsed.Morphs.Length; i++)
{
morphValues[i] = parsed.Morphs[i];
}
morphs = Builder.Dedup(MorphSet.TakeArray(morphValues));
}
else
{
morphs = MorphSet.Empty;
}
return(AddWord(parsed.Word, flags, morphs));
}
private bool TryParseFlag(string text, out FlagValue value) => TryParseFlag(StringSlice.Create(text), out value);
public bool ContainsFlag(FlagValue flag) => Detail.ContainsFlag(flag);
public Affix(TEntry entry, FlagValue aFlag, AffixEntryOptions options)
{
Entry = entry ?? throw new ArgumentNullException(nameof(entry));
AFlag = aFlag;
Options = options;
}
public bool ContainsContClass(FlagValue flag) => flag.HasValue && ContClass.Contains(flag);
