// ========================================================================
// Methods
#region === Methods
/// <summary>
/// Determines if a class will be reflected.
/// </summary>
/// <param name="nrClass">The class to test.</param>
/// <returns><c>True</c> if the class should be reflected.</returns>
public bool Reflect(NRClass nrClass)
{
FilterModifiers filterModifiers = GetFilterModifier(nrClass.AccessModifier);
filterModifiers |= nrClass.ClassModifier == ClassModifier.Static ? FilterModifiers.Static : FilterModifiers.Instance;
return(RuleMatch(FilterElements.Class, filterModifiers));
}
/// <summary>
/// Checks if there is a matching rule for the specified operation.
/// </summary>
/// <param name="nrElement">The type of the element to check.</param>
/// <param name="nrOperation">The operation to check.</param>
/// <returns><c>True</c> if there is a matching rule.</returns>
private bool Reflect(FilterElements nrElement, NROperation nrOperation)
{
FilterModifiers filterModifiers = GetFilterModifier(nrOperation.AccessModifier);
filterModifiers |= nrOperation.OperationModifier == OperationModifier.Static ? FilterModifiers.Static : FilterModifiers.Instance;
return(RuleMatch(nrElement, filterModifiers));
}
/// <summary>
/// Determines if a field will be reflected.
/// </summary>
/// <param name="nrField">The field to test.</param>
/// <returns><c>True</c> if the field should be reflected.</returns>
public bool Reflect(NRField nrField)
{
FilterModifiers filterModifiers = GetFilterModifier(nrField.AccessModifier);
filterModifiers |= nrField.FieldModifier == FieldModifier.Static ? FilterModifiers.Static : FilterModifiers.Instance;
FilterElements filterElement = nrField.IsConstant ? FilterElements.Constant : FilterElements.Field;
return(RuleMatch(filterElement, filterModifiers));
}
/// <summary>
/// Checks if there is a rule matching the given values.
/// </summary>
/// <param name="element">The element of the rule to check.</param>
/// <param name="modifier">The modifier of the rule to check.</param>
/// <returns><c>True</c> if there is a rule.</returns>
private bool RuleMatch(FilterElements element, FilterModifiers modifier)
{
foreach (FilterRule rule in Rules)
{
if ((rule.Element == FilterElements.AllElements) || (rule.Element == element))
{
if ((rule.Modifier == FilterModifiers.AllModifiers) || ((rule.Modifier & modifier) != 0))
{
return(true);
}
}
}
return(false);
//return Rules.Where(rule => rule.Element == FilterElements.AllElements || rule.Element == element)
// .Any(rule => rule.Modifier == FilterModifiers.AllModifiers || (rule.Modifier & modifier) != 0);
}
/// <summary>
/// Creates a new FilterRule with the given values.
/// </summary>
/// <param name="modifier">The Modifier for this rule.</param>
/// <param name="element">The element for this rule</param>
public FilterRule(FilterModifiers modifier, FilterElements element)
: this()
{
Element = element;
Modifier = modifier;
}
/// <summary>
/// Checks if there is a matching rule for the specified type.
/// </summary>
/// <param name="nrElement">The type of the element to check.</param>
/// <param name="nrType">The type to check.</param>
/// <returns><c>True</c> if there is a matching rule.</returns>
private bool Reflect(FilterElements nrElement, NRTypeBase nrType)
{
FilterModifiers filterModifiers = GetFilterModifier(nrType.AccessModifier);
return(RuleMatch(nrElement, filterModifiers));
}