/*
* Copyright 2005 JBoss Inc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.drools.decisiontable.parser;
import java.util.ArrayList;
import java.util.List;
import org.drools.core.util.StringUtils;
import org.drools.decisiontable.parser.DefaultRuleSheetListener;
import org.drools.template.model.Condition;
import org.drools.template.model.Consequence;
import org.drools.template.model.Rule;
import org.drools.template.model.SnippetBuilder;
/**
* href="mailto:michael.neale@gmail.com"> Michael Neale </a>
*
* Define a ruleset spreadsheet which contains a matrix style decision tables.
*
* This is an example of a custom RuleSheetListener. It differs from the standard
* decision table in the following ways:
* - AgendaGroup property so that all rules fall within the same agenda-group
* - Precondition property which specifies a condition that is always included
* if a rule is being generated
* - Action property. Each cell within the decision table causes this action
* to be triggered
* - HorizontalCondition property. Each column header in the matrix
* applies this condition
* - VerticalCondition property. Each row header in the matrix applies this
* condition
*
* A table is identifed by a cell beginning with the text "RuleTable".
* The cells after RuleTable in the same row identify the Horizontal Conditions.
* The cells after RuleTable in the same column identify the Vertical Conditions.
* The cells with the matrix identify the actions.
* Wherever an action cell exists for a Vertical/Horizontal condition intersection
* the following rule is created:
* rule "rule_row_col"
* agenda-group AgendaGroup
* when
* Precondition
* VerticalCondition
* HorizontalCondition
* then
* Action
* end
*/
public class RuleMatrixSheetListener extends DefaultRuleSheetListener {
//keywords
public static final String AGENDAGROUP_TAG = "AgendaGroup";
public static final String PRECONDITION_TAG = "Precondition";
public static final String ACTION_TAG = "Action";
public static final String HORIZONTALCONDITION_TAG = "HorizontalCondition";
public static final String VERTICALCONDITION_TAG = "VerticalCondition";
//state machine variables for this parser
private int ruleTableRow;
private int ruleTableColumn;
private String _currentAgendaGroup;
private Condition _currentPrecondition;
private String _action;
private String _horizontalCondition;
private String _verticalCondition;
private List<Condition> _horizontalConditions = new ArrayList<Condition>();
private Condition _currentVerticalCondition;
private boolean isInRuleTable;
private Rule firstRule;
public void newCell(final int row,
final int column,
final String value,
final int mergedColStart) {
// if we aren't in the rule table just use the default handling
// (add a property)
if ( ! isInRuleTable ) {
super.newCell( row, column, value, mergedColStart );
return;
}
// ignore empty cells
if ( StringUtils.isEmpty( value ) ) {
return;
}
//Horizontal header column
//Create a new condition using HorizontalCondition as the template
//and save it for later use
if ( row == (ruleTableRow) && column > ruleTableColumn ) {
_horizontalConditions.add( createCondition( value, _horizontalCondition ) );
}
//Vertical header column
//Create a new condition using VerticalCondition as the template
//and set it as the current condition
else if ( row > (ruleTableRow) && column == ruleTableColumn ) {
_currentVerticalCondition = createCondition( value, _verticalCondition );
}
//Intersection column
//Create a new Consequence
else if ( row > (ruleTableRow) && column > ruleTableColumn ) {
createRule( row, column, value );
}
}
private void createRule(final int row,
final int column,
final String value) {
final Consequence consequence = createConsequence( value );
Rule rule = firstRule;
if ( rule == null ) {
rule = new Rule( "rule_" + row + "_" + column,
null,
row );
addRule( rule );
} else {
firstRule = null;
rule.setName( "rule_" + row + "_" + column );
}
rule.setAgendaGroup( this._currentAgendaGroup );
rule.addCondition( this._currentPrecondition );
rule.addCondition( _currentVerticalCondition );
rule.addCondition( (Condition) _horizontalConditions.get( column - (ruleTableColumn + 1) ) );
rule.addConsequence( consequence );
}
private Consequence createConsequence(final String value) {
final SnippetBuilder snip = new SnippetBuilder( _action );
final String result = snip.build( value );
final Consequence consequence = new Consequence();
consequence.setSnippet( result );
return consequence;
}
private Condition createCondition(final String value,
final String conditionTemplate) {
SnippetBuilder snip = new SnippetBuilder( conditionTemplate );
String result = snip.build( value );
Condition condition = new Condition();
condition.setSnippet( result );
return condition;
}
public void newRow(int rowNumber,
int columns) {
// nothing to do here
}
public void finishSheet() {
// nothing to do here
}
protected void postInitRuleTable(int row,
int column,
String value) {
this.firstRule = getCurrentRule();
}
/**
* This gets called each time a "new" rule table is found.
*/
protected void preInitRuleTable(final int row,
final int column,
final String value) {
this.ruleTableColumn = column;
this.ruleTableRow = row;
this.isInRuleTable = true;
this._currentAgendaGroup = getProperties().getSingleProperty( AGENDAGROUP_TAG );
this._action = getProperties().getSingleProperty( ACTION_TAG );
this._horizontalCondition = getProperties().getSingleProperty( HORIZONTALCONDITION_TAG );
this._verticalCondition = getProperties().getSingleProperty( VERTICALCONDITION_TAG );
String precondition = getProperties().getSingleProperty( PRECONDITION_TAG );
if ( precondition != null ) {
this._currentPrecondition = new Condition();
this._currentPrecondition.setSnippet( precondition );
}
}
}