[jboss-svn-commits] JBL Code SVN: r20041 - labs/jbossrules/branches/parser-rewrite/drools-compiler/src/main/java/org/drools/lang/descr.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Mon May 19 13:37:43 EDT 2008
Author: porcelli
Date: 2008-05-19 13:37:43 -0400 (Mon, 19 May 2008)
New Revision: 20041
Modified:
labs/jbossrules/branches/parser-rewrite/drools-compiler/src/main/java/org/drools/lang/descr/DescrFactory.java
Log:
Full rewrite:
- All the methods receive params from parser and returns a full filled element.
Modified: labs/jbossrules/branches/parser-rewrite/drools-compiler/src/main/java/org/drools/lang/descr/DescrFactory.java
===================================================================
--- labs/jbossrules/branches/parser-rewrite/drools-compiler/src/main/java/org/drools/lang/descr/DescrFactory.java 2008-05-19 17:36:16 UTC (rev 20040)
+++ labs/jbossrules/branches/parser-rewrite/drools-compiler/src/main/java/org/drools/lang/descr/DescrFactory.java 2008-05-19 17:37:43 UTC (rev 20041)
@@ -1,71 +1,832 @@
package org.drools.lang.descr;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.drools.lang.DroolsTree;
+
/**
- * This is the factory for ALL descriptors (eventually).
- * This will be tied in a with a package builder session, so it can add in context information for
- * validation when parsing.
+ * This is the factory for ALL descriptors.
*
- * @author Michael Neale
- *
+ * @author porcelli
+ *
*/
public class DescrFactory {
- public PackageDescr createPackage(final String packageName) {
- return new PackageDescr( packageName );
- }
+ public PackageDescr createPackage(List<DroolsTree> idList) {
+ PackageDescr packageDescr = new PackageDescr(
+ createDotedIdFromList(idList));
- public GlobalDescr createGlobal() {
- return new GlobalDescr();
- }
+ if (null != idList && idList.size() > 0) {
+ packageDescr.setLocation(getLineLocation(idList.get(0)),
+ getColumnLocation(idList.get(0)));
+ packageDescr
+ .setStartCharacter(getStartOffsetLocation(idList.get(0)));
+ packageDescr.setEndLocation(getLineLocation(idList.get(0)),
+ getEndOffsetLocation(idList.get(0)));
+ packageDescr.setEndCharacter(getEndOffsetLocation(idList.get(0)));
+ }
- public FromDescr createFrom() {
- return new FromDescr();
- }
+ return packageDescr;
+ }
- public AccumulateDescr createAccumulate() {
- return new AccumulateDescr();
- }
+ public AttributeDescr createAttribute(DroolsTree attributeName,
+ DroolsTree value) {
+ AttributeDescr attributeDescr = new AttributeDescr(attributeName
+ .getText());
+ attributeDescr.setLocation(getLineLocation(attributeName),
+ getColumnLocation(attributeName));
- public CollectDescr createCollect() {
- return new CollectDescr();
- }
+ attributeDescr.setStartCharacter(getStartOffsetLocation(attributeName));
- public ForallDescr createForall() {
- return new ForallDescr();
- }
+ if (null != value) {
+ if (value.getText().startsWith("\"")) {
+ attributeDescr.setValue(value.getText().substring(1,
+ value.getText().length() - 1));
+ } else {
+ attributeDescr.setValue(value.getText());
+ }
+ attributeDescr.setEndLocation(getLineLocation(value),
+ getEndOffsetLocation(value));
+ attributeDescr.setEndCharacter(getEndOffsetLocation(value));
+ } else {
+ attributeDescr.setEndLocation(getLineLocation(attributeName),
+ getEndOffsetLocation(attributeName));
+ attributeDescr.setEndCharacter(getEndOffsetLocation(attributeName));
+ attributeDescr.setValue("true");
+ }
- public ImportDescr createImport() {
- return new ImportDescr();
- }
+ return attributeDescr;
+ }
- public FunctionImportDescr createFunctionImport() {
- return new FunctionImportDescr();
- }
+ public FunctionImportDescr createFunctionImport(DroolsTree importStart,
+ List<DroolsTree> idList, DroolsTree dotStar) {
- public QueryDescr createQuery(final String queryName) {
- return new QueryDescr( queryName,
- "" );
- }
+ return (FunctionImportDescr) createGenericImport(
+ new FunctionImportDescr(), importStart, idList, dotStar);
+ }
- public FunctionDescr createFunction(final String functionName,
- final String returnType) {
- return new FunctionDescr( functionName,
- returnType );
- }
+ public ImportDescr createImport(DroolsTree importStart,
+ List<DroolsTree> idList, DroolsTree dotStar) {
- public FactTemplateDescr createFactTemplate(final String templateName) {
- return new FactTemplateDescr( templateName );
- }
+ return createGenericImport(new ImportDescr(), importStart, idList,
+ dotStar);
+ }
- public FieldTemplateDescr createFieldTemplate() {
- return new FieldTemplateDescr();
- }
+ private ImportDescr createGenericImport(ImportDescr importDescr,
+ DroolsTree importStart, List<DroolsTree> idList, DroolsTree dotStar) {
+ ImportDescr genericImport = importDescr;
- public EntryPointDescr createEntryPoint() {
- return new EntryPointDescr();
- }
-
- public TypeDeclarationDescr createTypeDeclaration() {
- return new TypeDeclarationDescr();
- }
-}
+ genericImport.setLocation(getLineLocation(importStart),
+ getColumnLocation(importStart));
+ genericImport.setStartCharacter(getStartOffsetLocation(importStart));
+
+ genericImport.setEndLocation(getLineLocation(idList
+ .get(idList.size() - 1)), getEndOffsetLocation(idList
+ .get(idList.size() - 1)));
+
+ genericImport.setEndCharacter(getEndOffsetLocation(idList.get(idList
+ .size() - 1)));
+
+ StringBuilder sb = new StringBuilder();
+ sb.append(createDotedIdFromList(idList));
+ if (null != dotStar) {
+ sb.append(".*");
+ genericImport.setEndLocation(getLineLocation(dotStar),
+ getEndOffsetLocation(dotStar));
+ genericImport.setEndCharacter(getEndOffsetLocation(dotStar));
+ }
+ genericImport.setTarget(sb.toString());
+
+ return genericImport;
+ }
+
+ public GlobalDescr createGlobal(DroolsTree start, BaseDescr dataType,
+ DroolsTree globalId) {
+ GlobalDescr globalDescr = new GlobalDescr();
+
+ globalDescr.setIdentifier(globalId.getText());
+ globalDescr.setType(dataType.getText());
+
+ globalDescr.setLocation(getLineLocation(start),
+ getColumnLocation(start));
+ globalDescr.setEndLocation(getLineLocation(globalId),
+ getEndOffsetLocation(globalId));
+ globalDescr.setEndCharacter(getEndOffsetLocation(globalId));
+
+ return globalDescr;
+ }
+
+ public FunctionDescr createFunction(DroolsTree start, BaseDescr dataType,
+ DroolsTree functionId, List<Map<BaseDescr, BaseDescr>> params,
+ DroolsTree content) {
+ String type = null;
+ if (null != dataType) {
+ type = dataType.getText();
+ }
+
+ FunctionDescr functionDescr = new FunctionDescr(functionId.getText(),
+ type);
+
+ for (Map<BaseDescr, BaseDescr> map : params) {
+ for (Entry<BaseDescr, BaseDescr> entry : map.entrySet()) {
+ functionDescr.addParameter(entry.getValue().getText(), entry
+ .getKey().getText());
+ }
+ }
+
+ functionDescr.setText(content.getText().substring(1,
+ content.getText().length() - 1));
+
+ functionDescr.setLocation(getLineLocation(start),
+ getColumnLocation(start));
+ functionDescr.setEndCharacter(getEndOffsetLocation(content));
+
+ return functionDescr;
+ }
+
+ public FactTemplateDescr createFactTemplate(DroolsTree start,
+ DroolsTree id, List<FieldTemplateDescr> slotList, DroolsTree end) {
+ FactTemplateDescr factTemplateDescr = new FactTemplateDescr(
+ getCleanId(id));
+ for (FieldTemplateDescr fieldTemplateDescr : slotList) {
+ factTemplateDescr.addFieldTemplate(fieldTemplateDescr);
+ }
+
+ factTemplateDescr.setLocation(getLineLocation(start),
+ getColumnLocation(start));
+ factTemplateDescr.setEndLocation(getLineLocation(end),
+ getEndOffsetLocation(end));
+ factTemplateDescr.setEndCharacter(getEndOffsetLocation(end));
+
+ return factTemplateDescr;
+ }
+
+ public FieldTemplateDescr createFieldTemplate(BaseDescr dataType,
+ DroolsTree id) {
+ FieldTemplateDescr fieldTemplateDescr = new FieldTemplateDescr();
+ fieldTemplateDescr.setClassType(dataType.getText());
+ fieldTemplateDescr.setName(id.getText());
+
+ fieldTemplateDescr
+ .setLocation(dataType.getLine(), dataType.getColumn());
+ fieldTemplateDescr.setEndLocation(getLineLocation(id),
+ getEndOffsetLocation(id));
+ fieldTemplateDescr.setEndCharacter(getEndOffsetLocation(id));
+
+ return fieldTemplateDescr;
+ }
+
+ public QueryDescr createQuery(DroolsTree start, DroolsTree id,
+ List<Map<BaseDescr, BaseDescr>> params, AndDescr andDescr,
+ DroolsTree end) {
+
+ QueryDescr queryDescr = new QueryDescr(getCleanId(id), "");
+
+ if (null != params && params.size() > 0) {
+ ArrayList<String> paramList = new ArrayList<String>(params.size());
+ ArrayList<String> dataTypeList = new ArrayList<String>(params
+ .size());
+ for (Map<BaseDescr, BaseDescr> map : params) {
+ for (Entry<BaseDescr, BaseDescr> entry : map.entrySet()) {
+ paramList.add(entry.getKey().getText());
+ if (null == entry.getValue()) {
+ dataTypeList.add("Object");
+ } else {
+ dataTypeList.add(entry.getValue().getText());
+ }
+ }
+ }
+ queryDescr.setParameters((String[]) paramList.toArray());
+ queryDescr.setParameterTypes((String[]) dataTypeList.toArray());
+ }
+
+ queryDescr.setLhs(andDescr);
+ queryDescr
+ .setLocation(getLineLocation(start), getColumnLocation(start));
+ queryDescr.setEndLocation(getLineLocation(end),
+ getEndOffsetLocation(end));
+ queryDescr.setEndCharacter(getEndOffsetLocation(end));
+
+ return queryDescr;
+ }
+
+ public RuleDescr createRule(DroolsTree start, DroolsTree id,
+ List<AttributeDescr> attributeList, AndDescr andDescr,
+ DroolsTree content) {
+
+ RuleDescr ruleDescr = new RuleDescr(getCleanId(id), null);
+
+ if (null != attributeList && attributeList.size() > 0) {
+ for (AttributeDescr attributeDescr : attributeList) {
+ ruleDescr.addAttribute(attributeDescr);
+ }
+ }
+
+ if (null == andDescr) {
+ ruleDescr.setLhs(new AndDescr());
+ } else {
+ ruleDescr.setLhs(andDescr);
+ }
+
+ // ignoring first line in the consequence
+ String buf = content.getText();
+ // removing final END keyword
+ int idx = 4;
+ while (idx < buf.length() - 3
+ && (buf.charAt(idx) == ' ' || buf.charAt(idx) == '\t')) {
+ idx++;
+ }
+ if (idx < buf.length() - 3 && buf.charAt(idx) == '\r')
+ idx++;
+ if (idx < buf.length() - 3 && buf.charAt(idx) == '\n')
+ idx++;
+ buf = buf.substring(idx, buf.length() - 3);
+ ruleDescr.setConsequence(buf);
+ ruleDescr.setConsequenceLocation(getLineLocation(content), getColumnLocation(content));
+
+ ruleDescr.setLocation(getLineLocation(start), getColumnLocation(start));
+ ruleDescr.setEndCharacter(getEndOffsetLocation(content));
+
+ return ruleDescr;
+ }
+
+ // LHS
+ public BaseDescr createOr(DroolsTree start, List<BaseDescr> lhsList) {
+ OrDescr or = new OrDescr();
+ or.setLocation(getColumnLocation(start), getColumnLocation(start));
+ or.setStartCharacter(getStartOffsetLocation(start));
+ or.setEndLocation(lhsList.get(lhsList.size() - 1).getEndLine(), lhsList
+ .get(lhsList.size() - 1).getEndColumn());
+ or.setEndCharacter(lhsList.get(lhsList.size() - 1).getEndCharacter());
+ for (BaseDescr baseDescr : lhsList) {
+ or.addDescr(baseDescr);
+ }
+ return or;
+ }
+
+ public BaseDescr createAnd(DroolsTree start, List<BaseDescr> lhsList) {
+ AndDescr and = new AndDescr();
+ and.setLocation(getColumnLocation(start), getColumnLocation(start));
+ and.setStartCharacter(getStartOffsetLocation(start));
+ and.setEndLocation(lhsList.get(lhsList.size() - 1).getEndLine(),
+ lhsList.get(lhsList.size() - 1).getEndColumn());
+ and.setEndCharacter(lhsList.get(lhsList.size() - 1).getEndCharacter());
+ for (BaseDescr baseDescr : lhsList) {
+ and.addDescr(baseDescr);
+ }
+ return and;
+ }
+
+ public BaseDescr createExists(DroolsTree start, BaseDescr baseDescr) {
+ ExistsDescr exists = new ExistsDescr();
+ exists.setLocation(getColumnLocation(start), getColumnLocation(start));
+ exists.setStartCharacter(getStartOffsetLocation(start));
+ exists.setEndLocation(baseDescr.getEndLine(), baseDescr.getEndColumn());
+ exists.setEndCharacter(baseDescr.getEndCharacter());
+ exists.addDescr(baseDescr);
+ return exists;
+ }
+
+ public BaseDescr createNot(DroolsTree start, BaseDescr baseDescr) {
+ NotDescr not = new NotDescr();
+ not.setLocation(getColumnLocation(start), getColumnLocation(start));
+ not.setStartCharacter(getStartOffsetLocation(start));
+ not.setEndLocation(baseDescr.getEndLine(), baseDescr.getEndColumn());
+ not.setEndCharacter(baseDescr.getEndCharacter());
+ not.addDescr(baseDescr);
+ return not;
+ }
+
+ public BaseDescr createEval(DroolsTree start, DroolsTree content) {
+ EvalDescr eval = new EvalDescr();
+ eval.setLocation(getColumnLocation(start), getColumnLocation(start));
+ eval.setStartCharacter(getStartOffsetLocation(start));
+ eval.setEndCharacter(getEndOffsetLocation(content));
+ eval.setContent(content.getText().substring(1,
+ content.getText().length() - 1));
+ return eval;
+ }
+
+ public BaseDescr createForAll(DroolsTree start, List<BaseDescr> lhsList) {
+ ForallDescr forAll = new ForallDescr();
+ forAll.setLocation(getColumnLocation(start), getColumnLocation(start));
+ forAll.setStartCharacter(getStartOffsetLocation(start));
+ forAll.setEndLocation(lhsList.get(lhsList.size() - 1).getEndLine(),
+ lhsList.get(lhsList.size() - 1).getEndColumn());
+ forAll.setEndCharacter(lhsList.get(lhsList.size() - 1)
+ .getEndCharacter());
+ for (BaseDescr baseDescr : lhsList) {
+ forAll.addDescr(baseDescr);
+ }
+ return forAll;
+ }
+
+ public AccumulateDescr createAccumulate(){
+ return new AccumulateDescr();
+ }
+
+ public PatternSourceDescr createAccumulate(DroolsTree start,
+ BaseDescr baseDescr) {
+ AccumulateDescr accumulate = new AccumulateDescr();
+ accumulate.setLocation(getColumnLocation(start),
+ getColumnLocation(start));
+ accumulate.setStartCharacter(getStartOffsetLocation(start));
+ accumulate.setInput(baseDescr);
+
+ return accumulate;
+ }
+
+ public PatternSourceDescr createEntryPoint(DroolsTree start,
+ DroolsTree entryId) {
+ EntryPointDescr entryPoint = new EntryPointDescr();
+ entryPoint.setLocation(getColumnLocation(start),
+ getColumnLocation(start));
+ entryPoint.setStartCharacter(getStartOffsetLocation(start));
+ entryPoint.setEndLocation(getLineLocation(entryId),
+ getColumnLocation(entryId));
+ entryPoint.setEndCharacter(getEndOffsetLocation(entryId));
+ entryPoint.setEntryId(entryId.getText());
+ return entryPoint;
+ }
+
+ public PatternSourceDescr createCollect(DroolsTree start,
+ BaseDescr baseDescr) {
+ CollectDescr collect = new CollectDescr();
+ collect.setLocation(getColumnLocation(start), getColumnLocation(start));
+ collect.setStartCharacter(getStartOffsetLocation(start));
+ collect
+ .setEndLocation(baseDescr.getEndLine(), baseDescr
+ .getEndColumn());
+ collect.setEndCharacter(baseDescr.getEndCharacter());
+ collect.setInputPattern((PatternDescr) baseDescr);
+ return collect;
+ }
+
+ public AccessorDescr createAccessor(DroolsTree id, DroolsTree chunk) {
+ AccessorDescr accessor = new AccessorDescr(id.getText());
+ accessor.setLocation(getLineLocation(id), getColumnLocation(id));
+ accessor.setStartCharacter(getStartOffsetLocation(id));
+ accessor.setEndCharacter(getEndOffsetLocation(id));
+ if (chunk != null) {
+ accessor.setVariableName(null);
+ FunctionCallDescr functionCall = new FunctionCallDescr(id.getText());
+ functionCall
+ .setLocation(getLineLocation(id), getColumnLocation(id));
+ functionCall.setStartCharacter(getStartOffsetLocation(id));
+ functionCall.setEndCharacter(getEndOffsetLocation(chunk));
+ functionCall.setArguments(chunk.getText());
+ accessor.addInvoker(functionCall);
+ }
+ return accessor;
+ }
+
+ public DeclarativeInvokerDescr createExpressionChain(DroolsTree start,
+ DroolsTree id, DroolsTree squareChunk, DroolsTree parenChunk) {
+ DeclarativeInvokerDescr declarativeInvoker = null;
+ if (null == parenChunk) {
+ FieldAccessDescr field = new FieldAccessDescr(id.getText());
+ field.setLocation(getLineLocation(id), getColumnLocation(id));
+ field.setStartCharacter(getStartOffsetLocation(id));
+ field.setEndCharacter(getEndOffsetLocation(id));
+ if (null != squareChunk) {
+ field.setArgument(squareChunk.getText());
+ field.setEndCharacter(getEndOffsetLocation(squareChunk));
+ }
+ declarativeInvoker = field;
+ } else {
+ MethodAccessDescr method = new MethodAccessDescr(id.getText(),
+ parenChunk.getText());
+ method.setLocation(getLineLocation(id), getColumnLocation(id));
+ method.setStartCharacter(getStartOffsetLocation(id));
+ method.setEndCharacter(getEndOffsetLocation(parenChunk));
+ declarativeInvoker = method;
+ }
+
+ return declarativeInvoker;
+ }
+
+ public AccessorDescr setupAccessorOffset(AccessorDescr accessorDescr) {
+ if (null != accessorDescr.getInvokers()
+ && accessorDescr.getInvokers().size() > 0) {
+ BaseDescr desc = (BaseDescr) accessorDescr.getInvokers().get(
+ accessorDescr.getInvokers().size() - 1);
+ accessorDescr.setEndCharacter(desc.getEndCharacter());
+ }
+ return accessorDescr;
+ }
+
+ public FromDescr createFromSource(AccessorDescr accessor) {
+ FromDescr from = new FromDescr();
+ from.setDataSource(accessor);
+ from.setEndCharacter(accessor.getEndCharacter());
+ return from;
+ }
+
+ public BaseDescr setupFrom(BaseDescr from, PatternSourceDescr fromSource) {
+ PatternDescr tempFrom = (PatternDescr) from;
+ tempFrom.setSource(fromSource);
+ return tempFrom;
+ }
+
+ public AccumulateDescr setupAccumulateInit(
+ PatternSourceDescr accumulateParam, DroolsTree start,
+ DroolsTree initChunk, DroolsTree actionChunk,
+ DroolsTree resultChunk, DroolsTree reverseChunk) {
+ AccumulateDescr accumulate = (AccumulateDescr) accumulateParam;
+ accumulate.setEndCharacter(getEndOffsetLocation(resultChunk));
+ accumulate.setInitCode(initChunk.getText().substring(1,
+ initChunk.getText().length() - 1));
+ accumulate.setActionCode(actionChunk.getText().substring(1,
+ actionChunk.getText().length() - 1));
+ accumulate.setResultCode(resultChunk.getText().substring(1,
+ resultChunk.getText().length() - 1));
+ if (reverseChunk != null) {
+ accumulate.setReverseCode(reverseChunk.getText().substring(1,
+ reverseChunk.getText().length() - 1));
+ }
+
+ return accumulate;
+ }
+
+ public AccumulateDescr setupAccumulateId(
+ PatternSourceDescr accumulateParam, DroolsTree id,
+ DroolsTree expressionChunk) {
+ AccumulateDescr accumulate = (AccumulateDescr) accumulateParam;
+ accumulate.setEndCharacter(getEndOffsetLocation(expressionChunk));
+
+ accumulate.setExternalFunction(true);
+ accumulate.setFunctionIdentifier(id.getText());
+ accumulate.setExpression(expressionChunk.getText().substring(1,
+ expressionChunk.getText().length() - 1));
+ return accumulate;
+ }
+
+ public PatternDescr createPattern(BaseDescr dataType,
+ List<BaseDescr> exprList) {
+ PatternDescr pattern = new PatternDescr();
+ pattern.setLocation(dataType.getEndLine(), dataType.getEndColumn());
+ pattern.setEndLocation(dataType.getEndLine(), dataType.getEndColumn());
+ pattern.setEndCharacter(dataType.getEndCharacter());
+ pattern.setObjectType(dataType.getText());
+
+ if (null != exprList && exprList.size() > 0) {
+ if (exprList.size() == 1) {
+ if (exprList.get(0) instanceof FieldBindingDescr
+ && ((FieldBindingDescr) exprList.get(0))
+ .getFieldConstraint().getRestriction()
+ .getRestrictions().size() > 0) {
+ pattern.getConstraint().addDescr(exprList.get(0));
+ pattern.getConstraint().addDescr(
+ ((FieldBindingDescr) exprList.get(0))
+ .getFieldConstraint());
+ } else {
+ pattern.getConstraint().addOrMerge(exprList.get(0));
+ }
+ } else {
+ for (BaseDescr constraint : exprList) {
+ pattern.getConstraint().addDescr(constraint);
+ if (constraint instanceof FieldBindingDescr
+ && ((FieldBindingDescr) constraint)
+ .getFieldConstraint().getRestriction()
+ .getRestrictions().size() > 0) {
+ pattern.getConstraint().addDescr(
+ ((FieldBindingDescr) constraint)
+ .getFieldConstraint());
+ }
+ }
+ }
+ pattern.setEndCharacter(exprList.get(exprList.size() - 1)
+ .getEndCharacter());
+ }
+
+ return pattern;
+ }
+
+ public BaseDescr setupPatternBiding(DroolsTree label, BaseDescr fact) {
+ fact.setStartCharacter(getStartOffsetLocation(label));
+ if (fact instanceof OrDescr) {
+ ((PatternDescr) ((OrDescr) fact).getDescrs().get(0))
+ .setIdentifier(label.getText());
+ ((PatternDescr) ((OrDescr) fact).getDescrs().get(1))
+ .setIdentifier(label.getText());
+ } else {
+ ((PatternDescr) fact).setIdentifier(label.getText());
+ }
+ return fact;
+ }
+
+ public BaseDescr createFactOr(DroolsTree start, BaseDescr left,
+ BaseDescr right) {
+ OrDescr or = new OrDescr();
+ or.addDescr(left);
+ or.addDescr(right);
+ return or;
+ }
+
+ public BaseDescr createStringLiteralRestriction(DroolsTree s) {
+ LiteralRestrictionDescr stringLit = new LiteralRestrictionDescr();
+ stringLit.setType(LiteralRestrictionDescr.TYPE_STRING);
+ stringLit.setText(s.getText().substring(1, s.getText().length() - 1));
+ return stringLit;
+ }
+
+ public BaseDescr createIntLiteralRestriction(DroolsTree i) {
+ LiteralRestrictionDescr intLit = new LiteralRestrictionDescr();
+ intLit.setType(LiteralRestrictionDescr.TYPE_NUMBER);
+ intLit.setText(i.getText());
+ return intLit;
+ }
+
+ public BaseDescr createFloatLiteralRestriction(DroolsTree f) {
+ LiteralRestrictionDescr floatLit = new LiteralRestrictionDescr();
+ floatLit.setType(LiteralRestrictionDescr.TYPE_NUMBER);
+ floatLit.setText(f.getText());
+ return floatLit;
+ }
+
+ public BaseDescr createBoolLiteralRestriction(DroolsTree b) {
+ LiteralRestrictionDescr boolLit = new LiteralRestrictionDescr();
+ boolLit.setType(LiteralRestrictionDescr.TYPE_BOOLEAN);
+ boolLit.setText(b.getText());
+ return boolLit;
+ }
+
+ public BaseDescr createNullLiteralRestriction(DroolsTree n) {
+ LiteralRestrictionDescr nullLit = new LiteralRestrictionDescr();
+ nullLit.setType(LiteralRestrictionDescr.TYPE_NULL);
+ nullLit.setText(null);
+ return nullLit;
+ }
+
+ public BaseDescr createReturnValue(DroolsTree pc) {
+ ReturnValueRestrictionDescr returnValue = new ReturnValueRestrictionDescr();
+ returnValue.setContent(pc.getText().substring(1,
+ pc.getText().length() - 1));
+ returnValue.setLocation(getLineLocation(pc), getColumnLocation(pc));
+ returnValue.setStartCharacter(getStartOffsetLocation(pc));
+ returnValue.setEndCharacter(getEndOffsetLocation(pc));
+ return returnValue;
+ }
+
+ public BaseDescr createAccessorElement(DroolsTree id,
+ List<DroolsTree> squareChunk) {
+ BaseDescr element = new BaseDescr();
+ element.setLocation(getLineLocation(id), getColumnLocation(id));
+ element.setStartCharacter(getStartOffsetLocation(id));
+ element.setEndCharacter(getEndOffsetLocation(id));
+ StringBuilder sb = new StringBuilder();
+ sb.append(id.getText());
+ if (null != squareChunk && squareChunk.size() > 0) {
+ for (DroolsTree chunk : squareChunk) {
+ sb.append(chunk.getText());
+ }
+ element.setEndCharacter(getEndOffsetLocation(squareChunk
+ .get(squareChunk.size() - 1)));
+ }
+ element.setText(sb.toString());
+ return element;
+ }
+
+ public BaseDescr createAccessorPath(List<BaseDescr> aeList) {
+ StringBuilder sb = new StringBuilder();
+ sb.append(aeList.get(0).getText());
+ if (aeList.size() > 1) {
+ for (int i = 1; i < aeList.size(); i++) {
+ sb.append(".");
+ sb.append(aeList.get(i).getText());
+ }
+ }
+
+ EvaluatorBasedRestrictionDescr evaluator;
+ String name = sb.toString();
+ if (name.indexOf('.') > -1 || name.indexOf('[') > -1) {
+ evaluator = new QualifiedIdentifierRestrictionDescr();
+ } else {
+ evaluator = new VariableRestrictionDescr();
+ }
+ evaluator.setText(name);
+
+ return evaluator;
+ }
+
+ public FieldConstraintDescr createFieldConstraint(List<BaseDescr> aeList) {
+ StringBuilder sb = new StringBuilder();
+ sb.append(aeList.get(0).getText());
+ if (aeList.size() > 1) {
+ for (int i = 1; i < aeList.size(); i++) {
+ sb.append(".");
+ sb.append(aeList.get(i).getText());
+ }
+ }
+ FieldConstraintDescr fieldConstraint = new FieldConstraintDescr(sb
+ .toString());
+ fieldConstraint.setLocation(aeList.get(0).getLine(), aeList.get(0)
+ .getColumn());
+ fieldConstraint.setStartCharacter(aeList.get(0).getStartCharacter());
+ fieldConstraint.setEndCharacter(aeList.get(aeList.size() - 1)
+ .getEndCharacter());
+
+ return fieldConstraint;
+ }
+
+ public BaseDescr createFieldBinding(DroolsTree label, BaseDescr descr) {
+ FieldBindingDescr fieldBiding = new FieldBindingDescr();
+ fieldBiding.setLocation(getLineLocation(label),
+ getColumnLocation(label));
+ fieldBiding.setStartCharacter(getStartOffsetLocation(label));
+ FieldConstraintDescr fieldConstraint = (FieldConstraintDescr) descr;
+ fieldBiding.setIdentifier(label.getText());
+ fieldBiding.setFieldName(fieldConstraint.getFieldName());
+ fieldBiding.setFieldConstraint(fieldConstraint);
+ return fieldBiding;
+ }
+
+ public BaseDescr createOrRestrictionConnective(BaseDescr left,
+ BaseDescr right) {
+ BaseDescr or = null;
+ if (left instanceof RestrictionDescr) {
+ RestrictionConnectiveDescr restOr = new RestrictionConnectiveDescr(
+ RestrictionConnectiveDescr.OR);
+ restOr.addOrMerge((RestrictionDescr) left);
+ restOr.addOrMerge((RestrictionDescr) right);
+ or = restOr;
+ } else {
+ OrDescr consOr = new OrDescr();
+ consOr.addOrMerge(left);
+ consOr.addOrMerge(right);
+ or = consOr;
+ }
+
+ return or;
+
+ }
+
+ public BaseDescr createAndRestrictionConnective(BaseDescr left,
+ BaseDescr right) {
+ BaseDescr and = null;
+ if (left instanceof RestrictionDescr) {
+ RestrictionConnectiveDescr restAnd = new RestrictionConnectiveDescr(
+ RestrictionConnectiveDescr.AND);
+ restAnd.addOrMerge((RestrictionDescr) left);
+ restAnd.addOrMerge((RestrictionDescr) right);
+ and = restAnd;
+ } else {
+ AndDescr consAnd = new AndDescr();
+ consAnd.addOrMerge(left);
+ consAnd.addOrMerge(right);
+ and = consAnd;
+ }
+
+ return and;
+ }
+
+ public BaseDescr createRestrictionConnective(DroolsTree not,
+ List<BaseDescr> exprList) {
+
+ RestrictionConnectiveDescr group;
+ String op = null;
+
+ if (null == not) {
+ op = "==";
+ group = new RestrictionConnectiveDescr(
+ RestrictionConnectiveDescr.OR);
+ } else {
+ op = "!=";
+ group = new RestrictionConnectiveDescr(
+ RestrictionConnectiveDescr.AND);
+ }
+
+ for (BaseDescr baseDescr : exprList) {
+ if (baseDescr instanceof EvaluatorBasedRestrictionDescr) {
+ EvaluatorBasedRestrictionDescr evaluator = (EvaluatorBasedRestrictionDescr) baseDescr;
+ evaluator.setEvaluator(op);
+ evaluator.setNegated(false);
+ group.addRestriction(evaluator);
+ }
+ }
+
+ return group;
+ }
+
+ public BaseDescr setupRestriction(DroolsTree operator, DroolsTree not,
+ BaseDescr descr, DroolsTree param) {
+ BaseDescr retDescr = setupRestriction(operator, not, descr);
+ if (null != param && descr instanceof EvaluatorBasedRestrictionDescr) {
+ EvaluatorBasedRestrictionDescr evaluator = (EvaluatorBasedRestrictionDescr) descr;
+ evaluator.setParameterText(param.getText().substring(1,
+ param.getText().length() - 1));
+ }
+ return retDescr;
+ }
+
+ public BaseDescr setupRestriction(DroolsTree operator, DroolsTree not,
+ BaseDescr descr) {
+ if (descr instanceof EvaluatorBasedRestrictionDescr) {
+ EvaluatorBasedRestrictionDescr evaluator = (EvaluatorBasedRestrictionDescr) descr;
+ evaluator.setEvaluator(operator.getText());
+ if (null == not) {
+ evaluator.setNegated(false);
+ } else {
+ evaluator.setNegated(true);
+ }
+ }
+ return descr;
+ }
+
+ public BaseDescr createPredicate(DroolsTree pc) {
+ PredicateDescr predicate = new PredicateDescr();
+ predicate.setContent(pc.getText().subSequence(1,
+ pc.getText().length() - 1));
+ predicate.setEndCharacter(getEndOffsetLocation(pc));
+ return predicate;
+ }
+
+ public BaseDescr setupFieldConstraint(FieldConstraintDescr field,
+ BaseDescr descr) {
+ if (null != descr && descr instanceof RestrictionDescr) {
+ field.getRestriction().addOrMerge((RestrictionDescr) descr);
+ }
+ return field;
+ }
+
+ private String getCleanId(DroolsTree id) {
+ String cleanedId = id.getText();
+ if (cleanedId.startsWith("\"")) {
+ cleanedId = cleanedId.substring(1, cleanedId.length() - 1);
+ }
+ return cleanedId;
+ }
+
+ public BaseDescr createDataType(List<DroolsTree> idList,
+ List<DroolsTree> rightList) {
+ return createGenericBaseDescr(idList, rightList);
+ }
+
+ public BaseDescr createArgument(DroolsTree id, List<DroolsTree> rightList) {
+ List<DroolsTree> idList = new ArrayList<DroolsTree>(1);
+ idList.add(id);
+ return createGenericBaseDescr(idList, rightList);
+ }
+
+ private BaseDescr createGenericBaseDescr(List<DroolsTree> idList,
+ List<DroolsTree> rightList) {
+ int endLine = getLineLocation(idList.get(idList.size() - 1));
+ int endColumn = getEndOffsetLocation(idList.get(idList.size() - 1));
+ int endChar = getEndOffsetLocation(idList.get(idList.size() - 1));
+
+ StringBuilder text = new StringBuilder();
+ text.append(createDotedIdFromList(idList));
+
+ if (null != rightList && rightList.size() > 0) {
+ for (int i = 0; i < rightList.size(); i++) {
+ text.append("[]");
+ }
+
+ endLine = getLineLocation(rightList.get(idList.size() - 1));
+ endColumn = getEndOffsetLocation(rightList.get(idList.size() - 1));
+ endChar = getEndOffsetLocation(rightList.get(idList.size() - 1));
+ }
+
+ BaseDescr baseDescr = new BaseDescr();
+ baseDescr.setText(text.toString());
+ baseDescr.setLocation(getLineLocation(idList.get(0)),
+ getColumnLocation(idList.get(0)));
+ baseDescr.setEndLocation(endLine, endColumn);
+ baseDescr.setEndCharacter(endChar);
+
+ return baseDescr;
+ }
+
+ private String createDotedIdFromList(List<DroolsTree> idList) {
+ StringBuilder sb = new StringBuilder();
+
+ if (null != idList && idList.size() > 0) {
+ for (DroolsTree commonTree : idList) {
+ sb.append(commonTree.getText());
+ sb.append(".");
+ }
+ sb.deleteCharAt(sb.length() - 1);
+ }
+
+ return sb.toString();
+ }
+
+ private int getLineLocation(DroolsTree tree) {
+ return tree.getLine();
+ }
+
+ private int getColumnLocation(DroolsTree tree) {
+ return tree.getCharPositionInLine();
+ }
+
+ private int getEndOffsetLocation(DroolsTree tree) {
+ return tree.getEndCharOffset();
+ }
+
+ private int getStartOffsetLocation(DroolsTree tree) {
+ return tree.getStartCharOffset();
+ }
+}
\ No newline at end of file
More information about the jboss-svn-commits
mailing list