private IDictionary <int, IList <int> > FindAll(string match)
{
bool searchInSelection = HightlightedCellsBackground.Values.Sum(list => list.Count) > 1;
ComparisonOperation comparisonOperation = findAndReplaceDialog.GetComparisonOperation();
var foundCells = new Dictionary <int, IList <int> >();
for (int i = 0; i < Content.FilterLogic.PreprocessingData.Columns; i++)
{
var filters = CreateFilters(match, comparisonOperation, i);
bool[] filteredRows = Content.FilterLogic.GetFilterResult(filters, true);
var foundIndices = new List <int>();
for (int idx = 0; idx < filteredRows.Length; ++idx)
{
var notFilteredThusFound = !filteredRows[idx];
if (notFilteredThusFound)
{
foundIndices.Add(idx);
}
}
foundCells[i] = foundIndices;
IList <int> selectedList;
if (searchInSelection && HightlightedCellsBackground.TryGetValue(i, out selectedList))
{
foundCells[i] = foundCells[i].Intersect(selectedList).ToList <int>();
}
else if (searchInSelection)
{
foundCells[i].Clear();
}
}
return(MapToSorting(foundCells));
}
public static ExprBinaryOp GetExprComparison(Expr left, Expr right, ComparisonOperation op)
{
if (op == ComparisonOperation.Equals)
{
return(new OData.ExprEquals(left, right));
}
else if (op == ComparisonOperation.NotEquals)
{
return(new OData.ExprNotEquals(left, right));
}
else if (op == ComparisonOperation.GreaterThan)
{
return(new OData.ExprGreaterThan(left, right));
}
else if (op == ComparisonOperation.GreaterThanOrEquals)
{
return(new OData.ExprGreaterThanOrEquals(left, right));
}
else if (op == ComparisonOperation.LesserThan)
{
return(new OData.ExprLesserThan(left, right));
}
else if (op == ComparisonOperation.LesserThanOrEquals)
{
return(new OData.ExprLesserThanOrEquals(left, right));
}
throw new System.ArgumentOutOfRangeException();
}
private List <IFilter> CreateFilters(string match, ComparisonOperation comparisonOperation, int columnIndex)
{
IPreprocessingData preprocessingData = Content.FilterLogic.PreprocessingData;
IStringConvertibleValue value;
if (preprocessingData.VariableHasType <double>(columnIndex))
{
value = new DoubleValue();
}
else if (preprocessingData.VariableHasType <String>(columnIndex))
{
value = new StringValue();
}
else if (preprocessingData.VariableHasType <DateTime>(columnIndex))
{
value = new DateTimeValue();
}
else
{
throw new ArgumentException("unsupported type");
}
value.SetValue(match);
var comparisonFilter = new ComparisonFilter(preprocessingData, GetConstraintOperation(comparisonOperation), value, true);
comparisonFilter.ConstraintColumn = columnIndex;
return(new List <Filter.IFilter>()
{
comparisonFilter
});
}
public ComparisonExpression(ComparisonOperation op, TextExpression exp1, TextExpression exp2)
{
this._op = op;
this._exp1 = exp1;
this._exp2 = exp2;
this.RawValue = exp1.RawValue + (object)op + exp2.RawValue;
}
private bool ConsumeComparisonExpression()
{
TokenType tokenType1 = this.LookAheadFirst.TokenType;
TokenType tokenType2 = this.LookAheadSecond.TokenType;
if (!this.IsArithmeticExpression(tokenType1) || !this.IsComparisonOperator(tokenType2))
{
return(false);
}
TextExpression lookAheadFirst1 = this.LookAheadFirst;
this.DiscardToken();
ComparisonOperation comparisonOp = this.GetComparisonOp(tokenType2);
this.DiscardToken();
do
{
;
}while (this.DoExpressionRules());
if (!this.IsArithmeticExpression(this.LookAheadFirst.TokenType))
{
return(false);
}
TextExpression lookAheadFirst2 = this.LookAheadFirst;
this.DiscardToken();
this.PushToken((TextExpression) new ComparisonExpression(comparisonOp, lookAheadFirst1, lookAheadFirst2));
return(true);
}
private Core.ConstraintOperation GetConstraintOperation(ComparisonOperation comparisonOperation)
{
Core.ConstraintOperation constraintOperation = Core.ConstraintOperation.Equal;
switch (comparisonOperation)
{
case ComparisonOperation.Equal:
constraintOperation = Core.ConstraintOperation.Equal;
break;
case ComparisonOperation.Greater:
constraintOperation = Core.ConstraintOperation.Greater;
break;
case ComparisonOperation.GreaterOrEqual:
constraintOperation = Core.ConstraintOperation.GreaterOrEqual;
break;
case ComparisonOperation.Less:
constraintOperation = Core.ConstraintOperation.Less;
break;
case ComparisonOperation.LessOrEqual:
constraintOperation = Core.ConstraintOperation.LessOrEqual;
break;
case ComparisonOperation.NotEqual:
constraintOperation = Core.ConstraintOperation.NotEqual;
break;
}
return(constraintOperation);
}
// ********************************************************************
public static bool RunComparison(ComparisonOperation _comparison, float _first, float _second)
{
switch (_comparison)
{
case ComparisonOperation.EQUAL:
return(_first == _second);
case ComparisonOperation.NOT_EQUAL:
return(_first != _second);
case ComparisonOperation.GREATER_THAN:
return(_first > _second);
case ComparisonOperation.GREATER_THAN_EQUAL_TO:
return(_first >= _second);
case ComparisonOperation.LESS_THAN:
return(_first < _second);
case ComparisonOperation.LESS_THAN_EQUAL_TO:
return(_first <= _second);
default:
Debug.LogError("Invalid comparison operation provided: " + _comparison);
return(false);
}
}
public void ComparisonOperation_GetterWorksProperly()
{
// Act
ComparisonOperation actualComparisonOperation = _unaryStatement.ComparisonOperation;
// Assert
Assert.AreEqual(_expectedComparisonOperation, actualComparisonOperation);
}
public ConditionPreviousRank(XElement el)
{
if (el == null)
{
throw new ArgumentNullException("el");
}
Rank = RankManager.ParseRank(el.Attribute("val").Value);
Comparison = (ComparisonOperation)Enum.Parse(typeof(ComparisonOperation), el.Attribute("op").Value, true);
}
public static string GetComparisonOperator(ComparisonOperation comparisonOperation)
{
if (!ComparisonOperators.Keys.Contains(comparisonOperation))
{
throw new InvalidOperationException("Required operation was not recognized.");
}
return ComparisonOperators[comparisonOperation];
}
public void Visit(ComparisonOperation node)
{
BinaryOperationVisit(node);
if (special_object_return_type)
{
IC.Add(new CommentLine($"set bool as return type"));
IC.Add(new AssignmentStringToVariable(return_type_variable, "Bool"));
}
}
public static string GetComparisonOperator(ComparisonOperation comparisonOperation)
{
if (!ComparisonOperators.Keys.Contains(comparisonOperation))
{
throw new InvalidOperationException("Required operation was not recognized.");
}
return(ComparisonOperators[comparisonOperation]);
}
private static bool Compare(ComparisonOperation op, object var1, object var2)
{
dynamic v1 = var1;
dynamic v2 = var2;
if (v1 == null && v2 == null)
{
return(op == ComparisonOperation.Equality || op == ComparisonOperation.GreaterThanOrEqualTo || op == ComparisonOperation.LessThanOrEqualTo);
}
if (v1 == null || v2 == null)
{
return(op == ComparisonOperation.Inequality);
}
if (v1 is bool && v2 is bool) // Handle boolean comparison in a separate method.
{
return(CompareBoolean(op, (bool)v1, (bool)v2));
}
// Handle comparisons between boolean and numeric values.
if (v1 is bool)
{
return(CompareBoolean(op, (bool)v1, v2 != 0));
}
if (v2 is bool)
{
return(CompareBoolean(op, (bool)v2, v1 != 0));
}
// Match up decimal/double types.
TypeMatch(ref v1, ref v2);
switch (op)
{
case ComparisonOperation.Equality:
return(v1 == v2);
case ComparisonOperation.Inequality:
return(v1 != v2);
case ComparisonOperation.GreaterThan:
return(v1 > v2);
case ComparisonOperation.LessThan:
return(v1 < v2);
case ComparisonOperation.GreaterThanOrEqualTo:
return(v1 >= v2);
case ComparisonOperation.LessThanOrEqualTo:
return(v1 <= v2);
default:
throw new ArgumentOutOfRangeException(nameof(op), op, null);
}
}
public ConditionIntRange( XElement el ) {
if( el == null ) throw new ArgumentNullException( "el" );
Field = (ConditionField)Enum.Parse( typeof( ConditionField ), el.Attribute( "field" ).Value, true );
Value = Int32.Parse( el.Attribute( "val" ).Value );
if( el.Attribute( "op" ) != null ) {
Comparison = (ComparisonOperation)Enum.Parse( typeof( ComparisonOperation ), el.Attribute( "op" ).Value, true );
}
if( el.Attribute( "scope" ) != null ) {
Scope = (ConditionScopeType)Enum.Parse( typeof( ConditionScopeType ), el.Attribute( "scope" ).Value, true );
}
}
public void TestAppendString(ComparisonOperation op, string expected)
{
var variable = new VariableExpression("variable");
var value = new IntegerConstantExpression(99);
var expr = new ComparisonExpression(variable, op, value);
var builder = new StringBuilder();
expr.AppendString(builder);
Assert.That(builder.ToString(), Is.EqualTo(expected));
}
/// <summary>
/// Used to create: {ValueLeft}{ComparisonOperator}{ValueRight}
/// </summary>
public Expression(ComparisonOperation comparisonOperation, IValueType valueLeft, IValueType valueRight)
{
StringBuilder sb = new StringBuilder(512);
this._comparisonOperator = Operation.GetComparisonOperator(comparisonOperation);
sb.Append(valueLeft.ToString());
sb.Append(this._comparisonOperator);
sb.Append(valueRight.ToString());
this.Value = sb.ToString();
}
/// <summary>
/// Used to create: {ValueLeft}{ComparisonOperator}{ValueRight}
/// </summary>
public Expression(ComparisonOperation comparisonOperation, IValueType valueLeft, IValueType valueRight)
{
StringBuilder sb = new StringBuilder(512);
this.ComparisonOperator = Operation.GetComparisonOperator(comparisonOperation);
sb.Append(valueLeft.ToString());
sb.Append(this.ComparisonOperator);
sb.Append(valueRight.ToString());
this.Value = sb.ToString();
}
public ConditionPreviousRank(Rank rank, ComparisonOperation comparison)
{
if (rank == null)
{
throw new ArgumentNullException("rank");
}
if (!Enum.IsDefined(typeof(ComparisonOperation), comparison))
{
throw new ArgumentOutOfRangeException("comparison", "Unknown comparison type");
}
Rank = rank;
Comparison = comparison;
}
private string GetComparisonExpressionFormat(ComparisonOperation operation)
{
switch (operation)
{
case ComparisonOperation.Between:
return("{0} <= {1} and {1} <= {2}");
case ComparisonOperation.NotBetween:
return("{0} > {1} or {1} > {2}");
default:
throw new ArgumentOutOfRangeException(operation.ToString() + " is not a supported linear operation.");
}
}
private static bool CompareBoolean(ComparisonOperation op, bool var1, bool var2)
{
// ReSharper disable once SwitchStatementMissingSomeCases
switch (op)
{
case ComparisonOperation.Equality:
return(var1 == var2);
case ComparisonOperation.Inequality:
return(var1 != var2);
default:
throw new InvalidVariableOperationException($"Attempted to perform an {op} operation on a boolean value.");
}
}
public void Visit(ComparisonOperation node)
{
node.LeftOperand.Accept(this);
node.RightOperand.Accept(this);
if (node.LeftOperand.StaticType.Text != "Int" || node.RightOperand.StaticType.Text != "Int")
{
errors.Add(SemanticError.InvalidUseOfOperator(node, node.LeftOperand.StaticType, node.RightOperand.StaticType));
}
if (!scope.IsDefinedType("Bool", out node.StaticType))
{
errors.Add(SemanticError.NotDeclaredType(new TypeNode(node.Line, node.Column, "Bool")));
}
}
public UnaryStatement(string leftOperand, ComparisonOperation comparisonOperation, string rightOperand)
{
if (string.IsNullOrWhiteSpace(leftOperand))
{
throw new ArgumentNullException(nameof(leftOperand));
}
if (string.IsNullOrWhiteSpace(rightOperand))
{
throw new ArgumentNullException(nameof(rightOperand));
}
LeftOperand = leftOperand;
ComparisonOperation = comparisonOperation;
RightOperand = rightOperand;
}
void findAndReplaceDialog_FindNextEvent(object sender, EventArgs e)
{
if (searchIterator == null ||
currentSearchText != findAndReplaceDialog.GetSearchText() ||
currentComparisonOperation != findAndReplaceDialog.GetComparisonOperation())
{
searchIterator = new FindPreprocessingItemsIterator(FindAll(findAndReplaceDialog.GetSearchText()));
currentSearchText = findAndReplaceDialog.GetSearchText();
currentComparisonOperation = findAndReplaceDialog.GetComparisonOperation();
}
if (IsOneCellSelected())
{
var first = GetSelectedCells().First();
searchIterator.SetStartCell(first.Key, first.Value[0]);
}
bool moreOccurences = false;
currentCell = searchIterator.GetCurrent();
moreOccurences = searchIterator.MoveNext();
if (IsOneCellSelected() && currentCell != null)
{
var first = GetSelectedCells().First();
if (currentCell.Item1 == first.Key && currentCell.Item2 == first.Value[0])
{
if (!moreOccurences)
{
searchIterator.Reset();
}
currentCell = searchIterator.GetCurrent();
moreOccurences = searchIterator.MoveNext();
if (!moreOccurences)
{
searchIterator.Reset();
}
}
}
dataGridView.ClearSelection();
if (currentCell != null)
{
dataGridView[currentCell.Item1, currentCell.Item2].Selected = true;
dataGridView.CurrentCell = dataGridView[currentCell.Item1, currentCell.Item2];
}
}
public ConditionIntRange(XElement el)
{
if (el == null)
{
throw new ArgumentNullException("el");
}
Field = (ConditionField)Enum.Parse(typeof(ConditionField), el.Attribute("field").Value, true);
Value = Int32.Parse(el.Attribute("val").Value);
if (el.Attribute("op") != null)
{
Comparison = (ComparisonOperation)Enum.Parse(typeof(ComparisonOperation), el.Attribute("op").Value, true);
}
if (el.Attribute("scope") != null)
{
Scope = (ConditionScopeType)Enum.Parse(typeof(ConditionScopeType), el.Attribute("scope").Value, true);
}
}
internal static ComparisonOperation GetOppositeComparisonOperation(ComparisonOperation op)
{
switch (op)
{
case ComparisonOperation.Equal: return(ComparisonOperation.NotEqual);
case ComparisonOperation.NotEqual: return(ComparisonOperation.Equal);
case ComparisonOperation.LessThan: return(ComparisonOperation.GreaterThanOrEqual);
case ComparisonOperation.LessThanOrEqual: return(ComparisonOperation.GreaterThan);
case ComparisonOperation.GreaterThan: return(ComparisonOperation.LessThanOrEqual);
case ComparisonOperation.GreaterThanOrEqual: return(ComparisonOperation.LessThan);
default: return(ComparisonOperation.None);
}
}
private static RequirementOperator GetRequirementOperator(ComparisonOperation comparisonOperation)
{
switch (comparisonOperation)
{
case ComparisonOperation.Equal: return(RequirementOperator.Equal);
case ComparisonOperation.NotEqual: return(RequirementOperator.NotEqual);
case ComparisonOperation.LessThan: return(RequirementOperator.LessThan);
case ComparisonOperation.LessThanOrEqual: return(RequirementOperator.LessThanOrEqual);
case ComparisonOperation.GreaterThan: return(RequirementOperator.GreaterThan);
case ComparisonOperation.GreaterThanOrEqual: return(RequirementOperator.GreaterThanOrEqual);
default: return(RequirementOperator.None);
}
}
internal static string GetOperatorString(ComparisonOperation operation)
{
switch (operation)
{
case ComparisonOperation.Equal: return("==");
case ComparisonOperation.NotEqual: return("!=");
case ComparisonOperation.LessThan: return("<");
case ComparisonOperation.LessThanOrEqual: return("<=");
case ComparisonOperation.GreaterThan: return(">");
case ComparisonOperation.GreaterThanOrEqual: return(">=");
default: return(null);
}
}
public static bool Compare <U>(ComparisonOperation operation, U left, U right) where U : IComparable <U>
{
// compare them
int result = left.CompareTo(right);
switch (operation)
{
case ComparisonOperation.equal: return(result == 0);
case ComparisonOperation.notEqual: return(result != 0);
case ComparisonOperation.less: return(result < 0);
case ComparisonOperation.lessOrEqual: return(result <= 0);
case ComparisonOperation.greater: return(result > 0);
case ComparisonOperation.greaterOrEqual: return(result >= 0);
}
return(false);
}
private string GetOperationSymbol(ComparisonOperation operation)
{
switch (operation)
{
case ComparisonOperation.LessOrEqual:
return("<=");
case ComparisonOperation.Less:
return("<");
case ComparisonOperation.Equal:
return("==");
case ComparisonOperation.LargerOrEqual:
return(">=");
case ComparisonOperation.Larger:
return(">");
default:
throw new ArgumentOutOfRangeException(operation.ToString() + " is not a supported linear operation.");
}
}
public bool CalculateIfExcessGuideline(AnalyteGuidelineValue guideline, double?value, ComparisonOperation operation)
{
var decider = _factory.BuildDecider(guideline.GetType());
var isExcessed = decider.CalculateIfExcessGuideline(guideline, value, operation);
return(isExcessed);
}
public ConditionIntRange( ConditionField field, ComparisonOperation comparison, int value ) {
Field = field;
Comparison = comparison;
Value = value;
}
public ConditionMetadata(string fieldName, ComparisonOperation comparisonOperation, string value)
{
this.fieldName = fieldName;
this.comparisonOperation = comparisonOperation;
this.value = value;
}
private List<IFilter> CreateFilters(string match, ComparisonOperation comparisonOperation, int columnIndex) {
IPreprocessingData preprocessingData = Content.FilterLogic.PreprocessingData;
IStringConvertibleValue value;
if (preprocessingData.VariableHasType<double>(columnIndex)) {
value = new DoubleValue();
} else if (preprocessingData.VariableHasType<String>(columnIndex)) {
value = new StringValue();
} else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
value = new DateTimeValue();
} else {
throw new ArgumentException("unsupported type");
}
value.SetValue(match);
var comparisonFilter = new ComparisonFilter(preprocessingData, GetConstraintOperation(comparisonOperation), value, true);
comparisonFilter.ConstraintColumn = columnIndex;
return new List<Filter.IFilter>() { comparisonFilter };
}
private Core.ConstraintOperation GetConstraintOperation(ComparisonOperation comparisonOperation) {
Core.ConstraintOperation constraintOperation = Core.ConstraintOperation.Equal;
switch (comparisonOperation) {
case ComparisonOperation.Equal:
constraintOperation = Core.ConstraintOperation.Equal;
break;
case ComparisonOperation.Greater:
constraintOperation = Core.ConstraintOperation.Greater;
break;
case ComparisonOperation.GreaterOrEqual:
constraintOperation = Core.ConstraintOperation.GreaterOrEqual;
break;
case ComparisonOperation.Less:
constraintOperation = Core.ConstraintOperation.Less;
break;
case ComparisonOperation.LessOrEqual:
constraintOperation = Core.ConstraintOperation.LessOrEqual;
break;
case ComparisonOperation.NotEqual:
constraintOperation = Core.ConstraintOperation.NotEqual;
break;
}
return constraintOperation;
}
public ComparisonExpression(ExpressionBase left, ComparisonOperation operation, ExpressionBase right)
: base(left, right, ExpressionType.Comparison)
{
Operation = operation;
}
public IFluentQueryBuilder Where(string fieldName, ComparisonOperation comparisonOperation, string value)
{
ConditionMetadata condition = new ConditionMetadata(fieldName, comparisonOperation, value);
metadata.AddCondition(condition);
return this;
}
public ConditionPreviousRank( XElement el ) {
if( el == null ) throw new ArgumentNullException( "el" );
Rank = RankManager.ParseRank( el.Attribute( "val" ).Value );
Comparison = (ComparisonOperation)Enum.Parse( typeof( ComparisonOperation ), el.Attribute( "op" ).Value, true );
}
public bool CalculateIfExcessGuideline(AnalyteGuidelineValue guideline, double?value, ComparisonOperation operation)
{
if (!IsSupported(guideline, operation))
{
throw new ArgumentException("guideine type or the comparison operation is not supported by the " + this.GetType().Name);
}
var castedGuideline = (SimpleGuidelineValue)guideline;
if (value.HasValue && castedGuideline.GuidelineValue.HasValue)
{
var operationSymbol = GetOperationSymbol(operation);
var expressionString = String.Format("{0} {1} {2}", value.Value, operationSymbol, castedGuideline.GuidelineValue.Value);
var expression = new Expression(expressionString);
var result = (bool)expression.Evaluate();
return(!result);
}
return(false);
}
void findAndReplaceDialog_FindNextEvent(object sender, EventArgs e) {
if (searchIterator == null
|| currentSearchText != findAndReplaceDialog.GetSearchText()
|| currentComparisonOperation != findAndReplaceDialog.GetComparisonOperation()) {
searchIterator = new FindPreprocessingItemsIterator(FindAll(findAndReplaceDialog.GetSearchText()));
currentSearchText = findAndReplaceDialog.GetSearchText();
currentComparisonOperation = findAndReplaceDialog.GetComparisonOperation();
}
if (IsOneCellSelected()) {
var first = GetSelectedCells().First();
searchIterator.SetStartCell(first.Key, first.Value[0]);
}
bool moreOccurences = false;
currentCell = searchIterator.GetCurrent();
moreOccurences = searchIterator.MoveNext();
if (IsOneCellSelected() && currentCell != null) {
var first = GetSelectedCells().First();
if (currentCell.Item1 == first.Key && currentCell.Item2 == first.Value[0]) {
if (!moreOccurences) {
searchIterator.Reset();
}
currentCell = searchIterator.GetCurrent();
moreOccurences = searchIterator.MoveNext();
if (!moreOccurences) {
searchIterator.Reset();
}
}
}
dataGridView.ClearSelection();
if (currentCell != null) {
dataGridView[currentCell.Item1, currentCell.Item2].Selected = true;
dataGridView.CurrentCell = dataGridView[currentCell.Item1, currentCell.Item2];
}
}
public ConditionPreviousRank( Rank rank, ComparisonOperation comparison ) {
if( rank == null ) throw new ArgumentNullException( "rank" );
if( !Enum.IsDefined( typeof( ComparisonOperation ), comparison ) ) {
throw new ArgumentOutOfRangeException( "comparison", "Unknown comparison type" );
}
Rank = rank;
Comparison = comparison;
}
public void Visit(ComparisonOperation node)
{
throw new NotImplementedException();
}
