/// <summary>
/// Create a SimpleExpression or a BooleanExpression based on the string that this method receive
/// </summary>
/// <param name="SimpleExpression"></param>
/// <returns></returns>
public static BooleanOperand Create(string ExpressionToEvaluate)
{
Regex re;
Match m;
re = new Regex(@"(?<exp1>.*)\s*(?<op>[&][&]|[|][|])\s*(?<exp2>.*)\s*");
m = re.Match(ExpressionToEvaluate);
if (m.Success) // complex expression ==> a=1 && b>4
{
// exp2 is a simple expression for sure
BooleanOperand exp2 = BooleanOperand.Create(m.Groups["exp2"].Value);
BooleanOperatorType Operator = BooleanExpression.GetBooleanOperator(m.Groups["op"].Value);
BooleanOperand exp1 = BooleanOperand.Create(m.Groups["exp1"].Value);
BooleanExpression be = new BooleanExpression(exp1, Operator, exp2);
return(be);
}
// At this point it's a simple expression
re = new Regex(@"(?:(?<left>\w+)\s*(?<op>[=]|[>]|[<]|[<][=]|[>][=])\s*(?<right>[\x22]?\w+[\x22]?))");
m = re.Match(ExpressionToEvaluate);
if (!m.Success)
{
throw new Exception("Invalid SimpleExpression: " + ExpressionToEvaluate);
}
string Property = m.Groups["left"].Value;
string Value = m.Groups["right"].Value;
SimpleOperatorType ExpressionOperator = SimpleExpression.GetExpressionOperator(m.Groups["op"].Value);
SimpleExpression simple = new SimpleExpression(Property, ExpressionOperator, Value);
return(simple);
}
private string GetBooleanOperator(BooleanOperatorType type)
{
switch (type)
{
case BooleanOperatorType.Equals:
return(" = ");
case BooleanOperatorType.GreaterThan:
return(" > ");
case BooleanOperatorType.GreaterThanOrEqual:
return(" >= ");
case BooleanOperatorType.LessThan:
return(" < ");
case BooleanOperatorType.LessThanOrEqual:
return(" <= ");
case BooleanOperatorType.Like:
return(" LIKE ");
case BooleanOperatorType.NotEqual:
return(" <> ");
case BooleanOperatorType.NotGreaterThan:
return(" !> ");
case BooleanOperatorType.NotLessThan:
return(" !< ");
default:
throw new NotSupportedException();
}
}
public static BooleanOperatorType GetBooleanOperator(string OperatorValue)
{
BooleanOperatorType Op = BooleanOperatorType.And;
switch (OperatorValue)
{
case "&&":
Op = BooleanOperatorType.And;
break;
case "||":
Op = BooleanOperatorType.Or;
break;
}
return(Op);
}
public BooleanExpression(string Left, BooleanOperand Right)
{
Regex re = new Regex(@"(?:(?<exp>\S+)\s*(?<op>[&][&]|[|][|])\s*)|(?:(?<op>[&][&]|[|][|])\s*(?<exp>\S+)\s*)");
Match m = re.Match(Left);
if (!m.Success)
{
throw new Exception("Invalid SimpleExpression: " + Left);
}
//SimpleExpression exp = new SimpleExpression(m.Groups["exp"].Value);
BooleanOperand exp = BooleanOperand.Create(m.Groups["exp"].Value);
this.Left = exp;
this.Right = Right;
string op = m.Groups["op"].Value;
BooleanOperator = BooleanExpression.GetBooleanOperator(op);
}
public static dynamic GetTSObject(BooleanOperatorType dynEnum)
{
var tsType = TSActivator.CreateInstance("Tekla.Structures.Filtering.BooleanOperatorType").GetType();
switch (dynEnum)
{
case BooleanOperatorType.IS_EQUAL:
return(System.Enum.Parse(tsType, "IS_EQUAL"));
case BooleanOperatorType.IS_NOT_EQUAL:
return(System.Enum.Parse(tsType, "IS_NOT_EQUAL"));
case BooleanOperatorType.BOOLEAN_OR:
return(System.Enum.Parse(tsType, "BOOLEAN_OR"));
case BooleanOperatorType.BOOLEAN_AND:
return(System.Enum.Parse(tsType, "BOOLEAN_AND"));
default:
throw new DynamicAPIException(dynEnum.ToString() + "- enum value is not implemented");
}
}
public BooleanExpression(BooleanOperand Left, string Operator, BooleanOperand Right)
{
_Left = Left;
_BooleanOperator = BooleanExpression.GetBooleanOperator(Operator);
_Right = Right;
}
public BooleanExpression(BooleanOperand Left, BooleanOperatorType Operator, BooleanOperand Right)
{
_Left = Left;
_BooleanOperator = Operator;
_Right = Right;
}
