public string ReplaceVariables(MatchExpression expression, Dictionary <string, string> replaces)
{
var input = new StringBuilder(expression.Expression);
var padIndex = 0;
foreach (var match in expression.Matches)
{
var replace = replaces[match.Value];
if (replace == null)
{
continue;
}
var calculatedIndex = match.Index + padIndex;
input.Remove(calculatedIndex, match.Length);
input.Insert(calculatedIndex, replace);
if (match.Length != replace.Length)
{
padIndex += replace.Length - match.Length;
}
}
return(input.ToString());
}
private void regexColorRowGrid1_OnCellValueChanged(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0)
{
return;
}
if (e.ColumnIndex == _expressionIndex)
{
var grid = (DataGridView)sender;
var row = _bindingList[e.RowIndex];
var foreColor = Color.Black;
// If the MatchExpression is null, parsing failed, so we create a default expression where
// the regular expression is the Expression that failed to parse and the matchOptions are default ones (see GetDefaultMatchExpression)
if (row.MatchExpression == null)
{
if (!row.InvalidMatchOptions && MatchExpression.IsRegexValid(row.Expression))
{
row.Expression = GetDefaultMatchExpression(row.Expression).ToString();
}
else
{
foreColor = Color.Red;
}
}
grid[e.ColumnIndex, e.RowIndex].Style.ForeColor = foreColor;
}
}
private void Init(MatchExpression matchExpression, List <string> whereToSearch, Room roomToLeave)
{
this.matchExpression = matchExpression;
whereToSearchString = whereToSearch;
this.roomToLeave = roomToLeave;
isSearchListString = true;
}
public override void Accept(MatchExpression match)
{
AstNode value = match.Children [0];
value.Visit(this);
int temporary = methodBuilder.CreateTemporary();
methodBuilder.EmitInstruction(match.Location, Opcode.StoreLocal, temporary);
PatternCompiler compiler = new PatternCompiler(symbolTable, methodBuilder,
temporary,
this);
IodineLabel nextLabel = methodBuilder.CreateLabel();
IodineLabel endLabel = methodBuilder.CreateLabel();
for (int i = 1; i < match.Children.Count; i++)
{
if (i > 1)
{
methodBuilder.MarkLabelPosition(nextLabel);
nextLabel = methodBuilder.CreateLabel();
}
CaseExpression clause = match.Children [i] as CaseExpression;
clause.Pattern.Visit(compiler);
methodBuilder.EmitInstruction(match.Location, Opcode.JumpIfFalse, nextLabel);
if (clause.Condition != null)
{
clause.Condition.Visit(this);
methodBuilder.EmitInstruction(match.Location, Opcode.JumpIfFalse, nextLabel);
}
clause.Value.Visit(this);
methodBuilder.EmitInstruction(match.Location, Opcode.Jump, endLabel);
}
methodBuilder.MarkLabelPosition(endLabel);
}
private IExpression ParseMatchExpression()
{
IExpression expression = this.ParseSimpleExpression();
Token token = this.NextToken();
if (expression == null)
{
if (token == null)
{
return(null);
}
else
{
throw new ParserException(string.Format("Unexpected '{0}'", token.Value));
}
}
if (token != null && token.Type == TokenType.Operator && token.Value == "=")
{
expression = new MatchExpression(expression, this.ParseSimpleExpression());
return(expression);
}
else if (token != null && token.Type == TokenType.Operator && token.Value == "!")
{
expression = new SendExpression(expression, this.ParseSimpleExpression());
return(expression);
}
else
{
this.PushToken(token);
}
return(expression);
}
private void UpdateGrid(MatchExpression validForExpr)
{
if (!_allowUpdateGrid)
{
return;
}
var expr = GetCurrentMatchExpression();
if (!Equals(expr, validForExpr))
{
return;
}
bindingSource1.DataSource = null;
expressionTextBox.ForeColor = Color.Black;
if (!expr.IsRegexValid())
{
expressionTextBox.ForeColor = Color.Red;
return;
}
if (_filteredRows != null)
{
bindingSource1.DataSource = new BindingList <StringWrapper>(_filteredRows);
_filteredRows = null;
}
else
{
bindingSource1.DataSource = new BindingList <StringWrapper>(_foldChangeRows.Select(row =>
RowToString(expr, row)).ToArray());
}
}
public MatchExprInfo(MatchExpression matchExpression, VolcanoPlotPointsInfo expectedPointsInfo, List <string> expectedMatches, bool perProtein)
{
MatchExpression = matchExpression;
ExpectedPointsInfo = expectedPointsInfo;
ExpectedMatches = expectedMatches;
PerProtein = perProtein;
}
public void HasVariablesWithVariable()
{
Variable variable = new Variable("X");
MatchExpression expr = new MatchExpression(new VariableExpression(variable), new ConstantExpression(123));
Assert.IsTrue(expr.HasVariable());
}
/// <summary>
/// Visit match expression
/// </summary>
/// <param name="matchExpression"></param>
/// <returns></returns>
public Expression VisitMatch([NotNull] MatchExpression expression)
{
Check.NotNull(expression, nameof(expression));
var optional = expression.Optional
? "OPTIONAL "
: String.Empty;
_commandBuilder
.Append($"{optional}MATCH ");
Visit(expression.Pattern);
if (!(expression.Where is null))
{
// TODO: optimize where
_commandBuilder
.AppendLine()
.Append("WHERE ");
Visit(expression.Where);
}
return(expression);
}
private void Init(MatchExpression matchExpression, List <Room> whereToSearch, Room roomToLeave)
{
this.matchExpression = matchExpression;
whereToSearchRoom = whereToSearch;
this.roomToLeave = roomToLeave;
isSearchListRoom = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericMatcher{T}"/> class.
/// </summary>
/// <param name="matchExpression">The test that is performed to check if the value matches expectation.</param>
/// <exception cref="ArgumentNullException"><c>matchExpression</c> is null.</exception>
public GenericMatcher(MatchExpression matchExpression)
: base("generic match")
{
if (matchExpression == null)
{
throw new ArgumentNullException("matchExpression", "matchExpression must not be null.");
}
this.matchExpression = matchExpression;
}
public void MatchVariableWithInteger()
{
Context context = new Context();
Variable variable = new Variable("X");
MatchExpression expr = new MatchExpression(new VariableExpression(variable), new ConstantExpression(123));
Assert.AreEqual(123, expr.Evaluate(context));
Assert.AreEqual(123, context.GetValue("X"));
}
/// <summary>
/// Single selection.
/// </summary>
/// <returns></returns>
public ItemType SelectScalar <ItemType>(MatchExpression matchExpression)
where ItemType : class, IDBPersistent, new()
{
List <ItemType> results = Select <ItemType>(matchExpression, 1);
if (results.Count > 0)
{
return(results[0]);
}
return(null);
}
/// <summary>
/// Single selection.
/// </summary>
/// <returns></returns>
public bool SelectScalar <ItemType>(ItemType item, MatchExpression matchExpression)
where ItemType : class, IDBPersistent
{
DataSet set = Select(new string[] { GetTypeTableName(typeof(ItemType)) }, matchExpression, 1);
if (set != null && set.Tables.Count > 0 && set.Tables[0].Rows.Count > 0)
{
return(UpdateItemValues <ItemType>(item, GetTypePersistableProperties(typeof(ItemType), true, true, true), set.Tables[0].Rows[0]));
}
return(false);
}
/// <summary>
/// Evaluates a set of claims using the authorization operation.
/// </summary>
/// <param name="claimSet">The set of claims to be evaluated.</param>
/// <returns>True if the set of claims evaluates to true; otherwise false.</returns>
public override bool Evaluate(IEnumerable <Claim> claims)
{
if (claims == null)
{
throw new ArgumentNullException("claims");
}
IList <Claim> list = null;
Capl.Authorization.Operations.Operation operation = null;
MatchExpression exp = Capl.Authorization.Matching.MatchExpression.Create(this.MatchExpression.Type, null);
list = exp.MatchClaims(claims, this.MatchExpression.ClaimType, this.MatchExpression.Value);
if (list.Count == 0)
{
return(!this.MatchExpression.Required);
}
if (this.Issuer != null)
{
int count = list.Count;
for (int index = 0; index < count; index++)
{
if (list[index].Issuer != this.Issuer)
{
list.Remove(list[index]);
index--;
count--;
}
}
}
operation = Capl.Authorization.Operations.Operation.Create(this.Operation.Type, null);
foreach (Claim claim in list)
{
bool eval = operation.Execute(claim.Value, this.Operation.ClaimValue);
if (this.Evaluates && eval)
{
return(true);
}
if (!this.Evaluates && eval)
{
return(false);
}
}
return(!this.Evaluates);
}
/// <summary>
/// This will create object instances based on the type column names. All instances types must be child
/// types to the BaseItemType.
/// This is useful to store multiple types with same base type in a single table.
/// </summary>
public List <ItemBaseType> SelectDynamicType <ItemBaseType>(MatchExpression matchExpression,
string assemblyQualifiedTypeColumnName, int?limit)
where ItemBaseType : class, IDBPersistent
{
List <ItemBaseType> results = new List <ItemBaseType>();
string tableName = _tablesTypeNames[typeof(ItemBaseType)];
List <PropertyInfo> infos = this.GetTypePersistableProperties(typeof(ItemBaseType), true, true, true);
DataSet set = Select(new string[] { tableName }, matchExpression, limit);
foreach (DataRow row in set.Tables[0].Rows)
{
string typeName = (string)row[assemblyQualifiedTypeColumnName];
if (string.IsNullOrEmpty(typeName))
{
SystemMonitor.Error("Type name column not found.");
return(null);
}
ItemBaseType item = null;
Type type = Type.GetType(typeName);
if (type == null)
{
SystemMonitor.Error("Type provided was not found.");
return(null);
}
if (type.IsSubclassOf(typeof(ItemBaseType)) == false &&
type.GetInterface(typeof(ItemBaseType).Name) == null)
{
SystemMonitor.Error("Base type not corresponding.");
return(null);
}
ConstructorInfo constructor = type.GetConstructor(new Type[] { });
if (constructor == null)
{
SystemMonitor.Error("Type parameterless constructor not found.");
return(null);
}
item = (ItemBaseType)constructor.Invoke(null);
if (UpdateItemValues(item, infos, row))
{
results.Add(item);
}
}
return(results);
}
public void NoMatchWithException()
{
MatchExpression expr = new MatchExpression(new ConstantExpression(123), new ConstantExpression("foo"));
try
{
expr.Evaluate(null);
Assert.Fail();
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(InvalidOperationException));
Assert.AreEqual("no match of right hand side value foo", ex.Message);
}
}
public void AssertCorrect()
{
try
{
var parsed = MatchExpression.Parse(Expression);
Assert.AreEqual(Expected.RegExpr, parsed.RegExpr);
CollectionAssert.AreEqual(Expected.matchOptions, parsed.matchOptions);
}
catch (Exception ex)
{
if (ExceptionType == null || ExceptionType != ex.GetType())
{
Assert.Fail();
}
}
}
public void ParseSimpleMatch()
{
Parser parser = new Parser("X=ok.");
IExpression expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(MatchExpression));
MatchExpression matchexpression = (MatchExpression)expression;
Assert.IsNotNull(matchexpression.LeftExpression);
Assert.IsNotNull(matchexpression.RightExpression);
Assert.IsNull(parser.ParseExpression());
}
public override void Accept(MatchExpression match)
{
bool hasCatchall = false;
bool hasTruePattern = false;
bool hasFalsePattern = false;
foreach (AstNode node in match.MatchCases)
{
var matchCase = node as CaseExpression;
if (matchCase != null)
{
var nameExpr = matchCase.Pattern as NameExpression;
if (nameExpr != null && nameExpr.Value == "_")
{
hasCatchall = true;
}
var trueExpr = matchCase.Pattern as TrueExpression;
if (trueExpr != null)
{
hasTruePattern = true;
}
var falseExpr = matchCase.Pattern as FalseExpression;
if (falseExpr != null)
{
hasFalsePattern = true;
}
}
}
bool isLegal = hasCatchall || (hasTruePattern && hasFalsePattern);
if (!isLegal)
{
errorLog.Add(Errors.MatchDoesNotAccountForAllConditions,
match.Location);
}
base.Accept(match);
}
/// <summary>
/// Evaluates a set of claims using the authorization operation.
/// </summary>
/// <param name="claimSet">The set of claims to be evaluated.</param>
/// <returns>True if the set of claims evaluates to true; otherwise false.</returns>
public override bool Evaluate(IEnumerable <Claim> claims)
{
_ = claims ?? throw new ArgumentNullException(nameof(claims));
MatchExpression exp = Matching.MatchExpression.Create(MatchExpression.Type, null);
IList <Claim> list = exp.MatchClaims(claims, MatchExpression.ClaimType, MatchExpression.Value);
if (list.Count == 0)
{
return(!MatchExpression.Required);
}
if (Issuer != null)
{
int count = list.Count;
for (int index = 0; index < count; index++)
{
if (list[index].Issuer != Issuer)
{
list.Remove(list[index]);
index--;
count--;
}
}
}
Operation operation = Operations.Operation.Create(Operation.Type, null);
foreach (Claim claim in list)
{
bool eval = operation.Execute(claim.Value, Operation.ClaimValue);
if (Evaluates && eval)
{
return(true);
}
if (!Evaluates && eval)
{
return(false);
}
}
return(!Evaluates);
}
/// <summary>
///
/// </summary>
public long Count <ItemType>(MatchExpression matchExpression)
where ItemType : class, IDBPersistent
{
TracerHelper.TraceEntry(typeof(ItemType).Name);
string tableName = _tablesTypeNames[typeof(ItemType)];
StringBuilder commandText = new StringBuilder();
commandText.Append("SELECT count(*) FROM " + tableName);
if (matchExpression != null && matchExpression.ClauseCount > 0)
{
commandText.Append(" WHERE ");
}
_countMutex.WaitOne();
SQLiteCommand command;
long result = 0;
try
{
using (SQLiteConnection connection = GenerateConnection())
{
using (command = new SQLiteCommand(connection))
{
if (matchExpression != null)
{
matchExpression.SetupCommandParameters(command, commandText);
}
command.CommandText = commandText.ToString();
connection.Open();
result = (long)command.ExecuteScalar();
}
}
}
finally
{
_countMutex.ReleaseMutex();
}
TracerHelper.TraceExit();
return(result);
}
public void RaiseIfMatchVariableInTupleWithTwoDifferentValues()
{
Context context = new Context();
Variable x = new Variable("X");
MatchExpression expr = new MatchExpression(new TupleExpression(new IExpression[] { new VariableExpression(x), new VariableExpression(x) }), new TupleExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) }));
try
{
expr.Evaluate(context);
Assert.Fail();
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(InvalidOperationException));
Assert.AreEqual("no match of right hand side value {1,2}", ex.Message);
}
}
public void ParseMatchVariableWithInteger()
{
Parser parser = new Parser("X=1.");
IExpression expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(MatchExpression));
MatchExpression matchexpression = (MatchExpression)expression;
Assert.IsNotNull(matchexpression.LeftExpression);
Assert.IsInstanceOfType(matchexpression.LeftExpression, typeof(VariableExpression));
Assert.IsNotNull(matchexpression.RightExpression);
Assert.IsInstanceOfType(matchexpression.RightExpression, typeof(ConstantExpression));
Assert.IsNull(parser.ParseExpression());
}
public void MatchVariablesInTupleWithConcreteTuple()
{
Context context = new Context();
Variable x = new Variable("X");
Variable y = new Variable("Y");
MatchExpression expr = new MatchExpression(new TupleExpression(new IExpression[] { new VariableExpression(x), new VariableExpression(y) }), new TupleExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) }));
expr.Evaluate(context);
var result1 = context.GetValue("X");
var result2 = context.GetValue("Y");
Assert.IsNotNull(result1);
Assert.AreEqual(1, result1);
Assert.IsNotNull(result2);
Assert.AreEqual(2, result2);
}
public void simple_match_expression()
{
var target = new MatchExpression
{
new GuardNode
{
Test = new[] {new BoolLiteral(true),},
Result = new BoolLiteral(true)
},
new GuardNode
{
Test = new[] {new BoolLiteral(false),},
Result = new BoolLiteral(false)
}
};
target.Match = new[] {new BoolLiteral(true),};
Mother.Test(target.Compile(Mother.CreateRuntime()), true);
}
public void RaiseIfMatchBoundVariableWithInteger()
{
Context context = new Context();
Variable variable = new Variable("X");
context.SetValue("X", 1);
MatchExpression expr = new MatchExpression(new VariableExpression(variable), new ConstantExpression(123));
try
{
expr.Evaluate(context);
Assert.Fail();
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(InvalidOperationException));
Assert.AreEqual("no match of right hand side value 123", ex.Message);
}
}
/// <summary>
/// Executes the transform.
/// </summary>
/// <param name="claimSet">Input set of claims to transform.</param>
/// <returns>Transformed set of claims.</returns>
public override IEnumerable <Claim> TransformClaims(IEnumerable <Claim> claims)
{
if (claims == null)
{
throw new ArgumentNullException("claims");
}
TransformAction action = null;
IList <Claim> matchedClaims = null;
IEnumerable <Claim> transformedClaims = null;
bool eval = false;
action = TransformAction.Create(this.Type, null);
if (this.MatchExpression != null)
{
MatchExpression matcher = MatchExpressionDictionary.Default[this.MatchExpression.Type.ToString()]; //CaplConfigurationManager.MatchExpressions[this.MatchExpression.Type.ToString()];
matchedClaims = matcher.MatchClaims(claims, this.MatchExpression.ClaimType, this.MatchExpression.Value);
}
if (this.Expression == null)
{
eval = true;
}
else
{
eval = this.Expression.Evaluate(claims);
}
if (eval)
{
transformedClaims = action.Execute(claims, matchedClaims, this.TargetClaim);
}
if (transformedClaims != null)
{
return(transformedClaims);
}
else
{
return(claims);
}
}
/// <summary>
/// Extract type instances from storage, matching the provided criterias.
/// </summary>
/// <typeparam name="ItemType"></typeparam>
/// <param name="matchExpression">Pass null to include all items in select.</param>
/// <param name="limit">Pass null to specify no limit.</param>
/// <returns></returns>
public List <ItemType> Select <ItemType>(MatchExpression matchExpression, int?limit)
where ItemType : class, IDBPersistent, new()
{
List <ItemType> results = new List <ItemType>();
string tableName = _tablesTypeNames[typeof(ItemType)];
List <PropertyInfo> infos = this.GetTypePersistableProperties(typeof(ItemType), true, true, true);
DataSet set = Select(new string[] { tableName }, matchExpression, limit);
foreach (DataRow row in set.Tables[0].Rows)
{
ItemType item = new ItemType();
if (UpdateItemValues(item, infos, row))
{
results.Add(item);
}
}
return(results);
}
public void simple_match_expression()
{
var target = new MatchExpression
{
new GuardNode
{
Test = new[] { new BoolLiteral(true), },
Result = new BoolLiteral(true)
},
new GuardNode
{
Test = new[] { new BoolLiteral(false), },
Result = new BoolLiteral(false)
}
};
target.Match = new[] { new BoolLiteral(true), };
Mother.Test(target.Compile(Mother.CreateRuntime()), true);
}
// ReSharper restore PossibleMultipleEnumeration
private static TextObj CreateLabel(PointPair point, Color color, float size)
{
var row = point.Tag as FoldChangeBindingSource.FoldChangeRow;
if (row == null)
{
return(null);
}
var text = MatchExpression.GetRowDisplayText(row.Protein, row.Peptide);
var textObj = new TextObj(text, point.X, point.Y, CoordType.AxisXYScale, AlignH.Center, AlignV.Bottom)
{
IsClippedToChartRect = true,
FontSpec = CreateFontSpec(color, size),
ZOrder = ZOrder.A_InFront
};
return(textObj);
}
