private StatElement CreateElement( StatElementType type )
{
if ( _currentElement.Length > 0 ) {
StatElement element = new StatElement ();
if ( type == StatElementType.Variable ) {
switch ( _currentElement.ToString ().ToLower () ) {
case "true": element.Type = StatElementType.Constant;
element.Value = true;
break;
case "false": element.Type = StatElementType.Constant;
element.Value = false;
break;
case "like": element.Type = StatElementType.Operator;
element.Value = Operator.Like;
break;
case "null": element.Type = StatElementType.Constant;
element.Value = "null";
break;
default: element.Type = StatElementType.Variable;
element.Value = _currentElement.ToString ();
break;
}
} else if ( type == StatElementType.Operator ) {
element.Type = StatElementType.Operator;
element.Value = GetOperatorByString ( _currentElement.ToString () );
} else {
if ( _currentElement[0] != '\'' || _currentElement[_currentElement.Length - 1] != '\'' ) {
try {
double.Parse ( _currentElement.ToString () );
} catch {
throw new Exception ( string.Format ( "Invalid Vairable:{0}", _currentElement.ToString () ) );
}
}
element.Type = StatElementType.Constant;
element.Value = _currentElement.ToString ();
}
_currentElement.Remove ( 0, _currentElement.Length );
return element;
} else {
return null;
}
}
private static bool CalculateStringOperator( StatElement x, StatElement y, Operator @operator, object @object )
{
string xStr;
string yStr;
if ( x.Type == StatElementType.Variable ) {
PropertyInfo property = GetObjectProperty ( @object, ( string ) x.Value );
if ( property.PropertyType == typeof ( DateTime ) ) {
xStr = ( ( DateTime ) property.GetValue ( @object, null ) ).ToString ( "yyyy-MM-dd HH:mm:ss" );
} else {
xStr = ( string ) property.GetValue ( @object, null );
}
} else {
xStr = x.Value.ToString ();
}
if ( y.Type == StatElementType.Variable ) {
PropertyInfo property = GetObjectProperty ( @object, ( string ) y.Value );
if ( property.PropertyType == typeof ( DateTime ) ) {
yStr = ( ( DateTime ) property.GetValue ( @object, null ) ).ToString ( "yyyy-MM-dd HH:mm:ss" );
} else {
yStr = y.Value.ToString ();
}
} else {
yStr = y.Value.ToString ();
}
if ( xStr[0] == '\'' && xStr[xStr.Length - 1] == '\'' ) {
xStr = xStr.Substring ( 1, xStr.Length - 2 );
}
if ( yStr[0] == '\'' && yStr[yStr.Length - 1] == '\'' ) {
yStr = yStr.Substring ( 1, yStr.Length - 2 );
}
switch ( @operator ) {
case Operator.Equals: return xStr == yStr;
case Operator.UnEquals: return xStr != yStr;
case Operator.Like: return CalculateLikeOperator ( xStr, yStr, x.Type, y.Type );
default: throw new Exception ( "Invalid Statement" );
}
}
private void ProcessOperatorStack( StatElement element, Stack<StatElement> operatorStack )
{
if ( element.Type != StatElementType.Operator ) {
throw new Exception ( "element.Type must be StatElement.Operator" );
}
StatElement top;
if ( operatorStack.Count == 0 ) {
if ( ( Operator ) element.Value == Operator.RightParenthesis ) {
throw new Exception ( "( is expected" );
} else {
operatorStack.Push ( element );
}
} else if ( ( Operator ) element.Value == Operator.LeftParenthesis ) {
operatorStack.Push ( element );
} else if ( ( Operator ) element.Value == Operator.RightParenthesis ) {
top = operatorStack.Pop ();
while ( ( Operator ) top.Value != Operator.LeftParenthesis ) {
if ( operatorStack.Count == 0 ) {
throw new Exception ( "( is expected" );
}
_suffixExpression.Add ( top );
top = operatorStack.Pop ();
}
} else {
while ( operatorStack.Count > 0 ) {
top = operatorStack.Peek ();
if ( ( Operator ) top.Value == Operator.LeftParenthesis ) {
break;
}
if ( _priorityTable[( int ) element.Value, ( int ) top.Value] == 1 ) {
break;
}
_suffixExpression.Add ( operatorStack.Pop () );
}
operatorStack.Push ( element );
}
}
private static void ProcessVariable( object @object, StatElement element, Stack<StatElement> resultStack )
{
if ( @object.GetType ().GetProperty ( ( string ) element.Value ) != null ) {
resultStack.Push ( element );
} else {
throw new Exception ( string.Format ( "{0} do not contain the property:{1}", @object.GetType (), element.Value ) );
}
}
private static void ProcessNotOperator( Stack<StatElement> resultStack, object @object )
{
if ( resultStack.Count == 0 ) {
throw new Exception ( "Invalid Statement" );
}
StatElement element = resultStack.Pop ();
if ( element.Type == StatElementType.Result ) {
element.Value = !( ( bool ) element.Value );
} else if ( element.Type == StatElementType.Variable ) {
PropertyInfo property = GetObjectProperty ( @object, ( string ) element.Value );
if ( property.PropertyType == typeof ( bool ) ) {
element = new StatElement ();
element.Type = StatElementType.Result;
element.Value = !( ( bool ) property.GetValue ( @object, null ) );
} else {
throw new Exception ( string.Format ( "{0}.{1} is not a boolean property", @object.GetType (), property.Name ) );
}
} else {
if ( element.Value is bool ) {
element = new StatElement ();
element.Type = StatElementType.Result;
element.Value = !( ( bool ) element.Value );
} else {
throw new Exception ( string.Format ( "{0} is not boolean", element.Value ) );
}
}
resultStack.Push ( element );
}
private static void ProcessNotBooleanOperator( Stack<StatElement> resultStack, Operator @operator, object @object )
{
if ( resultStack.Count < 2 ) {
throw new Exception ( "Invalid Statement" );
}
StatElement y = resultStack.Pop ();
StatElement x = resultStack.Pop ();
StatElement element = new StatElement ();
object xValue;
object yValue;
element.Type = StatElementType.Result;
if ( x.Type == StatElementType.Variable ) {
xValue = GetObjectProperty ( @object, ( string ) x.Value ).GetValue ( @object, null );
} else {
xValue = x.Value;
}
if ( y.Type == StatElementType.Variable ) {
yValue = GetObjectProperty ( @object, ( string ) y.Value ).GetValue ( @object, null );
} else {
yValue = y.Value;
}
if ( IsString ( x, @object ) && IsString ( y, @object ) ) {
element.Value = CalculateStringOperator ( x, y, @operator, @object );
} else if ( !( IsString ( x, @object ) || IsString ( y, @object ) ) ) {
element.Value = CalculateNotBooleanOperator ( Convert.ToDouble ( xValue ), Convert.ToDouble ( yValue ), @operator );
} else {
throw new Exception ( "Invalid Statment" );
}
resultStack.Push ( element );
}
private static void ProcessBooleanOperator( Stack<StatElement> resultStack, Operator @operator, object @object )
{
if ( resultStack.Count < 2 ) {
throw new Exception ( "Invalid Statement" );
}
StatElement y = resultStack.Pop ();
StatElement x = resultStack.Pop ();
if ( x.Type == StatElementType.Variable ) {
GetObjectProperty ( @object, ( string ) x.Value );
}
if ( y.Type == StatElementType.Variable ) {
GetObjectProperty ( @object, ( string ) y.Value );
}
if ( x.Value is bool && y.Value is bool ) {
StatElement element = new StatElement ();
element.Type = StatElementType.Result;
element.Value = CalculateBooleanOperator ( ( bool ) x.Value, ( bool ) y.Value, @operator );
resultStack.Push ( element );
} else {
throw new Exception ( "Invalid Statement" );
}
}
private static bool IsString( StatElement element, object @object )
{
if ( element.Type == StatElementType.Variable ) {
Type type = @object.GetType ().GetProperty ( ( string ) element.Value ).PropertyType;
if ( type == typeof ( string ) || type == typeof ( DateTime ) || type == typeof ( char ) ) {
return true;
} else {
return false;
}
} else if ( element.Type == StatElementType.Constant ) {
string value = ( string ) element.Value;
if ( value.Length > 1 && value[0] == '\'' && value[value.Length - 1] == '\'' ) {
return true;
} else {
return false;
}
} else {
throw new Exception ( "'element' must a variable or constant" );
}
}
