private Expr parseExpr( String expr ) { List<String> splittedExpr = splitExpression( expr ); if ( splittedExpr.size() == 1 ) { String singleExpr = splittedExpr.get( 0 ); if ( singleExpr.startsWith( "(" ) ) { return parseExpr( singleExpr.substring( 1 ) ); } else if ( singleExpr.startsWith( "eval" ) ) { return new EvalExpr( unwrapParenthesis( singleExpr ) ); } else { return new SimpleExpr( singleExpr ); } } ComplexExpr complexExpr = new ComplexExpr( splittedExpr.get( 1 ) ); for ( int i = 0; i < splittedExpr.size(); i += 2 ) { complexExpr.subExprs.add( parseExpr( splittedExpr.get( i ) ) ); } return complexExpr; }
public FieldConstraint asFieldConstraint( FactPattern factPattern ) { String fieldName = expr; String operator = findOperator( expr ); String value = null; if ( operator != null ) { int opPos = expr.indexOf( operator ); fieldName = expr.substring( 0, opPos ).trim(); value = expr.substring( opPos + operator.length(), expr.length() ).trim(); } return fieldName.contains( "." ) ? asExpressionBuilderConstraint( factPattern, fieldName, operator, value ) : asSingleFieldConstraint( fieldName, operator, value ); }
private String setOperatorAndValueOnConstraint( String operator, String value, SingleFieldConstraint con ) { if ( operator != null ) { con.setOperator( operator ); boolean isAnd = value.contains( "&&" ); String[] splittedValue = isAnd ? value.split( "\\&\\&" ) : value.split( "\\|\\|" ); String type = setValueOnConstraint( operator, con, splittedValue[ 0 ].trim() ); if ( splittedValue.length > 1 ) { ConnectiveConstraint[] connectiveConstraints = new ConnectiveConstraint[ splittedValue.length - 1 ]; for ( int i = 0; i < connectiveConstraints.length; i++ ) { String constraint = splittedValue[ i + 1 ].trim(); String connectiveOperator = findOperator( constraint ); String connectiveValue = constraint.substring( connectiveOperator.length() ).trim(); connectiveConstraints[ i ] = new ConnectiveConstraint(); connectiveConstraints[ i ].setOperator( ( isAnd ? "&& " : "|| " ) + connectiveOperator ); setValueOnConstraint( operator, connectiveConstraints[ i ], connectiveValue ); } con.setConnectives( connectiveConstraints ); } return type; } return null; }
private FieldConstraint asExpressionBuilderConstraint( FactPattern factPattern, String fieldName, String operator, String value ) { SingleFieldConstraintEBLeftSide con = new SingleFieldConstraintEBLeftSide(); fieldName = setFieldBindingOnContraint( fieldName, con ); con.getExpressionLeftSide().appendPart( new ExpressionUnboundFact( factPattern ) ); String type = setOperatorAndValueOnConstraint( operator, value, con ); String[] splits = fieldName.split( "\\." ); for ( int i = 0; i < splits.length - 1; i++ ) { con.getExpressionLeftSide().appendPart( new ExpressionField( splits[ i ].trim(), "", DataType.TYPE_OBJECT ) ); } con.getExpressionLeftSide().appendPart( new ExpressionField( splits[ splits.length - 1 ].trim(), "", type ) ); return con; }
private FieldConstraint asSingleFieldConstraint( String fieldName, String operator, String value ) { SingleFieldConstraint con = new SingleFieldConstraint(); fieldName = setFieldBindingOnContraint( fieldName, con ); con.setFieldName( fieldName ); setOperatorAndValueOnConstraint( operator, value, con ); return con; }