/// <summary>
/// Creates a new <see cref="ILogEntryFilter" /> from the given values.
/// </summary>
/// <param name="value"></param>
/// <param name="matchType"></param>
/// <param name="ignoreCase"></param>
/// <param name="isInverted"></param>
/// <returns></returns>
public static ILogEntryFilter Create(string value, FilterMatchType matchType, bool ignoreCase, bool isInverted)
{
ILogEntryFilter filter = null;
switch (matchType)
{
case FilterMatchType.SubstringFilter:
if (!string.IsNullOrEmpty(value))
{
filter = new SubstringFilter(value, ignoreCase);
}
break;
case FilterMatchType.WildcardFilter:
if (!string.IsNullOrEmpty(value))
{
filter = new WildcardFilter(value, ignoreCase);
}
break;
case FilterMatchType.RegexpFilter:
if (!string.IsNullOrEmpty(value))
{
filter = new RegexFilter(value, ignoreCase);
}
break;
}
if (filter != null && isInverted)
{
filter = new InvertFilter(filter);
}
return(filter);
}
/// <summary>
/// Handles user comboBox selections to change the
/// default filtering Match Type.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void CbMatchTypeSelectedIndexChanged(object sender, EventArgs e)
{
FilterMatchType fms = (FilterMatchType)Enum.Parse(
typeof(FilterMatchType), cbMatchType.Text);
superGridControl1.PrimaryGrid.FilterMatchType = fms;
}
/// <summary>
/// Initializes a new instance of the RxStatusResponse class.
/// </summary>
/// <param name="receivedMessage">
/// RXxIF (CANINTF) bits are mapped to bits 7 and 6.</param>
/// <param name="messageTypeReceived">
/// The extended ID bit is mapped to bit 4. The RTR bit is mapped to bit 3.</param>
/// <param name="filterMatch"></param>
public RxStatusResponse(
FilterMatchType filterMatch,
MessageReceivedType messageTypeReceived,
ReceivedMessageType receivedMessage)
{
FilterMatch = filterMatch;
MessageTypeReceived = messageTypeReceived;
ReceivedMessage = receivedMessage;
}
private void OnIsRegexCheckedChanged(bool newValue)
{
if (newValue)
{
IsStringChecked = false;
IsWildcardChecked = false;
FilterMatchType = FilterMatchType.RegexpFilter;
}
}
/// <summary>
/// Restores this filter from the given xml reader.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public bool Restore(XmlReader reader)
{
var count = reader.AttributeCount;
for (var i = 0; i < count; ++i)
{
reader.MoveToAttribute(i);
switch (reader.Name)
{
case "id":
Id = reader.ReadContentAsQuickFilterId();
break;
case "type":
MatchType = reader.ReadContentAsEnum <FilterMatchType>();
break;
case "value":
Value = reader.Value;
break;
case "ignorecase":
IgnoreCase = reader.ReadContentAsBool();
break;
case "isinclude":
IsInverted = reader.ReadContentAsBool();
break;
}
}
if (Id == QuickFilterId.Empty)
{
return(false);
}
return(true);
}
public void TestRoundtrip([Values(true, false)] bool ignoreCase,
[Values(true, false)] bool isInverted,
[Values(FilterMatchType.RegexpFilter, FilterMatchType.SubstringFilter, FilterMatchType.WildcardFilter)] FilterMatchType matchType,
[Values("", "foo", "bar")] string value)
{
var id = QuickFilterId.CreateNew();
var config = new QuickFilter
{
Id = id,
IgnoreCase = ignoreCase,
IsInverted = isInverted,
MatchType = matchType,
Value = value
};
var actualQuickFilter = Roundtrip(config);
actualQuickFilter.Should().NotBeNull();
actualQuickFilter.Id.Should().Be(id);
actualQuickFilter.IgnoreCase.Should().Be(ignoreCase);
actualQuickFilter.IsInverted.Should().Be(isInverted);
actualQuickFilter.MatchType.Should().Be(matchType);
actualQuickFilter.Value.Should().Be(value);
}
public void To_Byte(FilterMatchType filterMatch, MessageReceivedType messageTypeReceived, ReceivedMessageType receivedMessage, byte expectedByte)
{
Assert.Equal(expectedByte, new RxStatusResponse(filterMatch, messageTypeReceived, receivedMessage).ToByte());
}
/// <summary>
/// Compares a node's research, unlocks and tech-level to the current filter. Updates the node of it's match status.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public FilterMatchType NodeIsMatch(Node node)
{
if (!FilterDirty)
{
return(FilterMatchType.NONE);
}
string phrase = _filterPhrase.Trim();
FilterMatchType ret = FilterMatchType.NONE;
string retDesc = StringExtensions.TitleCase(node.Research.LabelCap); // default
if (phrase != "")
{
foreach (FilterMatchType tryMatch in Enum.GetValues(typeof(FilterMatchType)))
{
Log.Message("trying match for " + tryMatch.ToString());
switch (tryMatch)
{
case FilterMatchType.RESEARCH:
if (node.Research.label.Contains(phrase, StringComparison.InvariantCultureIgnoreCase))
{
ret = FilterMatchType.RESEARCH;
}
break;
case FilterMatchType.UNLOCK:
{
List <string> unlockDescs = node.Research.GetUnlockDefsAndDescs()
.Where(unlock => unlock.First.label.Contains(phrase, StringComparison.InvariantCulture))
.Select(unlock => unlock.First.label).ToList();
if (unlockDescs.Count > 0)
{
retDesc = string.Format("{0} ({1})", retDesc, StringExtensions.TitleCase(string.Join(", ", unlockDescs.ToArray())));
ret = FilterMatchType.UNLOCK;
}
}
break;
case FilterMatchType.TECH_LEVEL:
{
if (node.Research.techLevel.ToStringHuman().Contains(phrase, StringComparison.InvariantCultureIgnoreCase))
{
ret = FilterMatchType.TECH_LEVEL;
}
}
break;
default:
ret = FilterMatchType.NO_MATCH;
break;
}
if (ret != FilterMatchType.NONE)
{
break;
}
}
}
else
{
ret = FilterMatchType.NONE;
}
// save the result for display later
if (ret.IsValidMatch())
{
if (!_matchResults.ContainsKey(ret))
{
_matchResults.Add(ret, new List <string>());
}
_matchResults[ret].Add(retDesc);
}
// update the node of the result
node.FilterMatch = ret;
return(ret);
}
private void OnFilterTypeChanged(FilterMatchType newValue)
{
IsStringChecked = newValue == FilterMatchType.SubstringFilter;
IsWildcardChecked = newValue == FilterMatchType.WildcardFilter;
IsRegexChecked = newValue == FilterMatchType.RegexpFilter;
}
///<summary>
/// Expression evaluator constructor
///</summary>
///<param name="gridPanel">Associated GridPanel</param>
///<param name="gridColumn"></param>
///<param name="matchType"></param>
///<param name="source"></param>
public FilterEval(GridPanel gridPanel,
GridColumn gridColumn, FilterMatchType matchType, string source)
{
_GridPanel = gridPanel;
_GridColumn = gridColumn;
_MatchType = matchType;
LoadLocalizedStrings();
Source = source;
}
public FilterBuilder(FilterMatchType matchType)
{
_filters = new List <Filter>();
MatchType = matchType;
}
public FilterBuilder(FilterMatchType matchType)
{
_filters = new List<Filter>();
MatchType = matchType;
}
