How to use

ExpressionFormLine

in

org.drools.guvnor.models.commons.shared.rule

private ExpressionFormLine visitExpressionFormLine( ExpressionFormLine efl ) {
  ExpressionFormLine clone = new ExpressionFormLine( efl );
  clone.setBinding( efl.getBinding() );
  return clone;
}

public ExpressionFormLine( ExpressionPart part ) {
  appendPart( part );
}

private String getCurrentClassType() {
  return expression.getClassType();
}

private String getBoundText() {
  if ( expression.isBound() ) {
    return "[" + expression.getBinding() + "] ";
  }
  return "";
}

private String paramsToString( Map<String, ExpressionFormLine> params ) {
  if ( params.isEmpty() ) {
    return "";
  }
  ToStringVisitor stringVisitor = new ToStringVisitor();
  StringBuilder strParams = new StringBuilder();
  for ( ExpressionFormLine param : params.values() ) {
    strParams.append( ", " ).append( stringVisitor.buildString( param.getBinding(),
                                  param.getRootExpression() ) );
  }
  return strParams.substring( 2 );
}

/**
 * This adds a new connective.
 */
@Override
public void addNewConnective() {
  String factType = getExpressionLeftSide().getPreviousGenericType();
  if ( factType == null ) {
    factType = getExpressionLeftSide().getGenericType();
  }
  String fieldName = getExpressionLeftSide().getFieldName();
  String fieldType = getExpressionLeftSide().getGenericType();
  if ( this.getConnectives() == null ) {
    this.setConnectives( new ConnectiveConstraint[]{ new ConnectiveConstraint( factType,
                                          fieldName,
                                          fieldType ) } );
  } else {
    final ConnectiveConstraint[] newList = new ConnectiveConstraint[ this.getConnectives().length + 1 ];
    for ( int i = 0; i < this.getConnectives().length; i++ ) {
      newList[ i ] = this.getConnectives()[ i ];
    }
    newList[ this.getConnectives().length ] = new ConnectiveConstraint( factType,
                                      fieldName,
                                      fieldType );
    this.setConnectives( newList );
  }
}

private void copyMethodParams( ExpressionMethod part,
                ExpressionMethod method ) {
  Map<String, ExpressionFormLine> params = new HashMap<String, ExpressionFormLine>();
  for ( Map.Entry<String, ExpressionFormLine> entry : part.getParams().entrySet() ) {
    params.put( entry.getKey(), new ExpressionFormLine( entry.getValue() ) );
  }
  method.setParams( params );
}

private void onCollectionChange( String value ) {
  if ( "size".contains( value ) ) {
    expression.appendPart( new ExpressionMethod( "size",
                           "int",
                           DataType.TYPE_NUMERIC_INTEGER ) );
  } else if ( "isEmpty".equals( value ) ) {
    expression.appendPart( new ExpressionMethod( "isEmpty",
                           "boolean",
                           DataType.TYPE_BOOLEAN ) );
                   new ExpressionFormLine( new ExpressionText( "0" ) ) );
      expression.appendPart( collectionIndex );
    } else if ( "last".equals( value ) ) {
      ExpressionFormLine index = new ExpressionFormLine( expression );
      index.appendPart( new ExpressionMethod( "size",
                          "int",
                          DataType.TYPE_NUMERIC_INTEGER ) );
      index.appendPart( new ExpressionText( "-1" ) );
      expression.appendPart( collectionIndex );

String prevFactName = null;
if ( DELETE_VALUE.equals( value ) ) {
  expression.removeLast();
} else if ( DataType.TYPE_COLLECTION.equals( getCurrentGenericType() ) ) {
  onCollectionChange( value );
} else if ( DataType.TYPE_STRING.equals( getCurrentGenericType() ) ) {
  if ( "size".equals( value ) ) {
    expression.appendPart( new ExpressionMethod( "size",
                           "int",
                           DataType.TYPE_NUMERIC_INTEGER ) );
  } else if ( "isEmpty".equals( value ) ) {
    expression.appendPart( new ExpressionText( ".size() == 0",
                          "",
                          DataType.TYPE_NUMERIC_INTEGER ) );
    expression.appendPart( ExpressionPartHelper.getExpressionPartForField( getCompletionEngine(),
                                        prevFactName,
                                        attrib ) );
  } else if ( METHOD_VALUE_PREFIX.equals( prefix ) ) {
    expression.appendPart( ExpressionPartHelper.getExpressionPartForMethod( getCompletionEngine(),
                                        prevFactName,
                                        attrib ) );
if ( !expression.isEmpty() ) {
  panel.add( createWidgetForExpression( expression.getText() + "." ) );

                        lhsBindingType );
  expression.appendPart( variable );
  expression.appendPart( ExpressionPartHelper.getExpressionPartForGlobalVariable( getCompletionEngine(),
                                          attrib ) );
if ( !expression.isEmpty() ) {
  panel.add( createWidgetForExpression( expression.getText() + "." ) );

private void visitSingleFieldConstraint( SingleFieldConstraintEBLeftSide sfexp ) {
  String genericType = sfexp.getExpressionLeftSide().getGenericType();
  String factType = sfexp.getExpressionLeftSide().getPreviousClassType();
  if ( factType == null ) {
    factType = sfexp.getExpressionLeftSide().getClassType();
  }
  InterpolationVariable var = new InterpolationVariable( sfexp.getValue(),
                              genericType,
                              factType,
                              sfexp.getFieldName() );
  if ( BaseSingleFieldConstraint.TYPE_TEMPLATE == sfexp.getConstraintValueType() && !vars.containsKey( var ) ) {
    vars.put( var,
         vars.size() );
  }
  //Visit Connection constraints
  if ( sfexp.getConnectives() != null ) {
    for ( int i = 0; i < sfexp.getConnectives().length; i++ ) {
      final ConnectiveConstraint cc = sfexp.getConnectives()[ i ];
      InterpolationVariable ccVar = new InterpolationVariable( cc.getValue(),
                                   genericType,
                                   factType,
                                   cc.getFieldName() );
      if ( BaseSingleFieldConstraint.TYPE_TEMPLATE == cc.getConstraintValueType() && !vars.containsKey( ccVar ) ) {
        vars.put( ccVar,
             vars.size() );
      }
    }
  }
}

this.expression = expression;
if ( this.expression.isEmpty() ) {
  this.isFactTypeKnown = true;
} else {
  this.isFactTypeKnown = getModeller().getSuggestionCompletions().isFactTypeRecognized( getModeller().getSuggestionCompletions().getFactNameFromType( this.expression.getRootExpression().getClassType() ) );
  bindingLabel.append( "</b>" );
bindingLabel.append( expression.getText( false ) );
if ( expression == null || expression.isEmpty() ) {
  if ( this.readOnly ) {
    panel.add( new SmallLabel( "<b>-</b>" ) );

public ExpressionFormLine( ExpressionFormLine other ) {
  CopyExpressionVisitor copier = new CopyExpressionVisitor();
  if ( other.getParts().size() == 0 ) {
    return;
  }
  for ( ExpressionPart exp = copier.copy( other.getRootExpression() ); exp != null; exp = exp.getNext() ) {
    parts.add( exp );
  }
}

@Override
public void setFieldBinding( String fieldBinding ) {
  getExpressionLeftSide().setBinding( fieldBinding );
}

  buf.append( ( (SingleFieldConstraintEBLeftSide) constr ).getExpressionLeftSide().getText() );
} else {
  String fieldName = constr.getFieldName();
addFieldRestriction( buf,
           sfexp.getConstraintValueType(),
           sfexp.getExpressionLeftSide().getGenericType(),
           sfexp.getOperator(),
           parameters,

@Override
public String getFieldBinding() {
  return getExpressionLeftSide().getBinding();
}

private Widget getWidgetForCurrentType() {
  if ( expression.isEmpty() ) {
    return createStartPointWidget();
  }
  ChangeHandler ch = new ChangeHandler() {
    public void onChange( ChangeEvent event ) {
      ListBox box = (ListBox) event.getSource();
      panel.remove( box );
      if ( box.getSelectedIndex() > 0 ) {
        onChangeSelection( box.getValue( box.getSelectedIndex() ) );
      }
    }
  };
  ListBox lb = new ListBox();
  lb.setVisibleItemCount( 1 );
  lb.addItem( Constants.INSTANCE.ChooseDotDotDot(),
        "" );
  lb.addItem( "<==" + Constants.INSTANCE.DeleteItem(),
        DELETE_VALUE );
  for ( Map.Entry<String, String> entry : getCompletionsForCurrentType( expression.getParts().size() > 1 ).entrySet() ) {
    lb.addItem( entry.getKey(),
          entry.getValue() );
  }
  lb.addChangeHandler( ch );
  return lb;
}

private String getCurrentGenericType() {
  return expression.getGenericType();
}

private String getPreviousGenericType() {
  return expression.getPreviousGenericType();
}

@Override
public String getFieldName() {
  return getExpressionLeftSide().getFieldName();
}