/// <summary>
/// Will return true if the instance failed the filtering conditions.
/// </summary>
public FilteringResultEnum FilterOutDetailed(EvaluationResultSet evaluationResultSet)
{ // For a condition to fail, it has to fail to both - positive and negative check.
if (Enabled == false)
{ // Filtering is disabled.
return(FilteringResultEnum.Disabled);
}
_totalItems++;
bool positiveFailResult =
(evaluationResultSet.CalculatePositivePerPosition() < PositivePerPosition ||
evaluationResultSet.CalculatePositiveSum() < PositiveSum ||
evaluationResultSet.PositiveEntries.Count < PositiveCount);
bool negativeFailResult =
(evaluationResultSet.CalculateNegativePerPosition() > NegativePerPosition ||
evaluationResultSet.CalculateNegativeSum() > NegativeSum ||
evaluationResultSet.NegativeEntries.Count < NegativeCount);
// By default - we need both to be failed, for the item to be flushed.
bool failResult = positiveFailResult && negativeFailResult;
if (CombinedFiltering)
{// When combined mode is on, we need only one to be failed - as we require both for pass result.
failResult = positiveFailResult || negativeFailResult;
}
if (failResult)
{
_filteredOutItems++;
}
if (!positiveFailResult && !negativeFailResult)
{
return(FilteringResultEnum.CombinedPass);
}
if (!positiveFailResult)
{
return(FilteringResultEnum.PositivePass);
}
if (!negativeFailResult)
{
return(FilteringResultEnum.NegativePass);
}
return(FilteringResultEnum.Failed);
}
/// <summary>
/// Static baseMethod allowing us to sort result sets.
/// </summary>
static public EvaluationResultSet[] SortResultSets(IEnumerable <EvaluationResultSet> resultSets,
bool positiveSet, SortResultsEnum sortCriteria)
{
SortedDictionary <Decimal, EvaluationResultSet> dictionary = new SortedDictionary <Decimal, EvaluationResultSet>();
foreach (EvaluationResultSet resultSet in resultSets)
{
// All the different values are coded in the double.
// As the last part is a unique index, so that if values match, sorting will still work properly.
double sortBasedValue = 0;
if (sortCriteria == SortResultsEnum.OriginalOrder)
{
sortBasedValue = dictionary.Count;
}
else if (sortCriteria == SortResultsEnum.Average)
{
if (positiveSet)
{
sortBasedValue = resultSet.CalculatePositivePerPosition();
}
else
{
sortBasedValue = resultSet.CalculateNegativePerPosition();
}
}
else if (sortCriteria == SortResultsEnum.Count)
{
if (positiveSet)
{
sortBasedValue = resultSet.PositiveEntries.Count;
}
else
{
sortBasedValue = resultSet.NegativeEntries.Count;
}
}
else if (sortCriteria == SortResultsEnum.Percentage)
{
if (positiveSet)
{
sortBasedValue = resultSet.CalculatePositiveWinningPercentage();
}
else
{
sortBasedValue = resultSet.CalcualteNegativeWinningPercentage();
}
}
else if (sortCriteria == SortResultsEnum.Sum)
{
if (positiveSet)
{
sortBasedValue = resultSet.CalculatePositiveSum();
}
else
{
sortBasedValue = resultSet.CalculateNegativeSum();
}
}
else
{
System.Diagnostics.Debug.Fail("Sorting case not handled.");
}
dictionary.Add(new Decimal(100000000 * sortBasedValue) + new Decimal(dictionary.Count), resultSet);
}
EvaluationResultSet[] result = new EvaluationResultSet[dictionary.Count];
dictionary.Values.CopyTo(result, 0);
return(result);
}
/// <summary>
/// Will return true if instance failed the filtering conditions.
/// </summary>
public bool FilterOut(EvaluationResultSet evaluationResultSet)
{
FilteringResultEnum result = FilterOutDetailed(evaluationResultSet);
return(!(result == FilteringResultEnum.Disabled || result == FilteringResultEnum.CombinedPass || result == FilteringResultEnum.PositivePass || result == FilteringResultEnum.NegativePass));
}
/// <summary>
/// Static baseMethod allowing us to sort result sets.
/// </summary>
public static EvaluationResultSet[] SortResultSets(IEnumerable<EvaluationResultSet> resultSets,
bool positiveSet, SortResultsEnum sortCriteria)
{
SortedDictionary<Decimal, EvaluationResultSet> dictionary = new SortedDictionary<Decimal, EvaluationResultSet>();
foreach (EvaluationResultSet resultSet in resultSets)
{
// All the different values are coded in the double.
// As the last part is a unique index, so that if values match, sorting will still work properly.
double sortBasedValue = 0;
if (sortCriteria == SortResultsEnum.OriginalOrder)
{
sortBasedValue = dictionary.Count;
}
else if (sortCriteria == SortResultsEnum.Average)
{
if (positiveSet)
{
sortBasedValue = resultSet.CalculatePositivePerPosition();
}
else
{
sortBasedValue = resultSet.CalculateNegativePerPosition();
}
}
else if (sortCriteria == SortResultsEnum.Count)
{
if (positiveSet)
{
sortBasedValue = resultSet.PositiveEntries.Count;
}
else
{
sortBasedValue = resultSet.NegativeEntries.Count;
}
}
else if (sortCriteria == SortResultsEnum.Percentage)
{
if (positiveSet)
{
sortBasedValue = resultSet.CalculatePositiveWinningPercentage();
}
else
{
sortBasedValue = resultSet.CalcualteNegativeWinningPercentage();
}
}
else if (sortCriteria == SortResultsEnum.Sum)
{
if (positiveSet)
{
sortBasedValue = resultSet.CalculatePositiveSum();
}
else
{
sortBasedValue = resultSet.CalculateNegativeSum();
}
}
else
{
System.Diagnostics.Debug.Fail("Sorting case not handled.");
}
dictionary.Add(new Decimal(100000000 * sortBasedValue) + new Decimal(dictionary.Count), resultSet);
}
EvaluationResultSet[] result = new EvaluationResultSet[dictionary.Count];
dictionary.Values.CopyTo(result, 0);
return result;
}
/// <summary>
/// Will return true if instance failed the filtering conditions.
/// </summary>
public bool FilterOut(EvaluationResultSet evaluationResultSet)
{
FilteringResultEnum result = FilterOutDetailed(evaluationResultSet);
return !(result == FilteringResultEnum.Disabled || result == FilteringResultEnum.CombinedPass || result == FilteringResultEnum.PositivePass || result == FilteringResultEnum.NegativePass);
}
/// <summary>
/// Will return true if the instance failed the filtering conditions.
/// </summary>
public FilteringResultEnum FilterOutDetailed(EvaluationResultSet evaluationResultSet)
{
// For a condition to fail, it has to fail to both - positive and negative check.
if (Enabled == false)
{// Filtering is disabled.
return FilteringResultEnum.Disabled;
}
_totalItems++;
bool positiveFailResult =
(evaluationResultSet.CalculatePositivePerPosition() < PositivePerPosition ||
evaluationResultSet.CalculatePositiveSum() < PositiveSum ||
evaluationResultSet.PositiveEntries.Count < PositiveCount );
bool negativeFailResult =
(evaluationResultSet.CalculateNegativePerPosition() > NegativePerPosition ||
evaluationResultSet.CalculateNegativeSum() > NegativeSum ||
evaluationResultSet.NegativeEntries.Count < NegativeCount);
// By default - we need both to be failed, for the item to be flushed.
bool failResult = positiveFailResult && negativeFailResult;
if (CombinedFiltering)
{// When combined mode is on, we need only one to be failed - as we require both for pass result.
failResult = positiveFailResult || negativeFailResult;
}
if (failResult)
{
_filteredOutItems++;
}
if (!positiveFailResult && !negativeFailResult)
{
return FilteringResultEnum.CombinedPass;
}
if (!positiveFailResult)
{
return FilteringResultEnum.PositivePass;
}
if (!negativeFailResult)
{
return FilteringResultEnum.NegativePass;
}
return FilteringResultEnum.Failed;
}
