|
1
23
24
27
28 package org.objectweb.medor.optim.lib;
29
30 import org.objectweb.jorm.type.api.PType;
31 import org.objectweb.jorm.type.api.PTypeSpace;
32 import org.objectweb.medor.api.MedorException;
33 import org.objectweb.medor.api.TupleStructure;
34 import org.objectweb.medor.filter.api.BelongOperator;
35 import org.objectweb.medor.expression.api.BinaryLogicalOperator;
36 import org.objectweb.medor.expression.api.Comparator;
37 import org.objectweb.medor.filter.api.ExpressionHelper;
38 import org.objectweb.medor.filter.api.FieldOperand;
39 import org.objectweb.medor.expression.api.ParameterOperand;
40 import org.objectweb.medor.expression.api.UnaryArithmeticOperator;
41 import org.objectweb.medor.expression.api.UnaryLogicalOperator;
42 import org.objectweb.medor.expression.api.Operand;
43 import org.objectweb.medor.expression.api.BinaryArithmeticOperator;
44 import org.objectweb.medor.expression.api.Expression;
45 import org.objectweb.medor.expression.api.ExpressionException;
46 import org.objectweb.medor.filter.postfix.PostfixExpressionHelper;
47 import org.objectweb.medor.optim.api.ExecPlanGenerator;
48 import org.objectweb.medor.query.api.CalculatedField;
49 import org.objectweb.medor.query.api.QueryNode;
50 import org.objectweb.medor.query.api.QueryTree;
51 import org.objectweb.medor.tuple.api.TupleLoader;
52 import org.objectweb.medor.type.lib.QTypeTuple;
53 import org.objectweb.util.io.api.Block;
54 import org.objectweb.util.io.api.TargetHolder;
55 import org.objectweb.util.io.lib.BlockImpl;
56 import org.objectweb.util.io.lib.JavaFileHolder;
57
58 import java.io.File  ;
59 import java.io.FileWriter ;
60 import java.io.IOException ;
61 import java.util.Enumeration ;
62 import java.util.HashSet ;
63 import java.util.Iterator ;
64 import java.util.Stack ;
65 import java.util.Vector ;
66
67 public class MedorSourceTypeCompiler implements ExecPlanGenerator {
68 private DirsCompileClassLoader mcl;
69 private TargetHolder queryFiltersHolder;
70 private TargetHolder tcTypeHolder;
71 private QueryTree queryTree;
72 private String sourceDirectory,classDirectory;
73 private HashSet library = new HashSet ();
74 ExpressionHelper eHelper = new PostfixExpressionHelper();
75 private int nbrFilter = 0;
76 private int nbrQTType = 0;
77 private static final String javaFilterName = "Filter";
78 private static final String javaTCTypeFileName = "QueryTreeType";
79
80 public MedorSourceTypeCompiler(String outputSourceDirectory,
81 String outputClassdirectory,
82 String [] libraryPaths)
83 throws MedorException {
84 try {
85 sourceDirectory = outputSourceDirectory;
86 classDirectory = outputClassdirectory;
87 File tadir;
88 tadir = new File (sourceDirectory);
89 if (!tadir.isDirectory()) {
90 throw new MedorException("the output directory parametre must be a directory: " + sourceDirectory);
91 }
92 library.add(sourceDirectory);
93
94 tadir = new File (classDirectory);
95 if (!tadir.isDirectory()) {
96 throw new MedorException("the output directory parametre must be a directory: " + classDirectory);
97 }
98 library.add(classDirectory);
99
100 for (int i = 0; (i < libraryPaths.length); i++) {
101 File targetDirectory = new File (libraryPaths[i]);
102 if (!targetDirectory.exists()) {
103 throw new MedorException("the path library " + libraryPaths[i] + "does not exist");
104 }
105 library.add(libraryPaths[i]);
106 }
107 queryFiltersHolder = new JavaFileHolder(sourceDirectory);
108 tcTypeHolder = new JavaFileHolder(sourceDirectory);
109 } catch (Exception e) {
110 throw new MedorException(e.getMessage());
111 }
112 }
113
114 public void builtFilterSources(QueryTree query) throws MedorException {
115 try {
116 if ((query instanceof QueryNode)
117 && (((QueryNode) query).getQueryFilter() != null)) {
118 QueryNode qn = (QueryNode) query;
119 generateFilter(qn.getQueryFilter(),
120 javaFilterName + nbrFilter++);
121 QueryTree[] qts = qn.getChildren();
122 for (int cpt = 0; (cpt < qts.length); cpt++)
123 builtFilterSources(qts[cpt]);
124 }
125 } catch (Exception e) {
126 throw new MedorException(e.getMessage());
127 }
128 }
129
130 public void builtTCTypeSources(QueryTree query) throws MedorException {
131 try {
132 if ((query instanceof QueryNode)
133 && ((QueryNode) query).getTupleLoader() != null) {
134 generateTCType(
135 ((QueryNode) query).getTupleLoader().getFieldIndexes(),
136 query.getTupleStructure(),
137 javaTCTypeFileName + nbrQTType++);
138 QueryTree[] qts = ((QueryNode) query).getChildren();
139 for (int cpt = 0; (cpt < qts.length); cpt++)
140 builtTCTypeSources(qts[cpt]);
141 }
142 } catch (Exception e) {
143 throw new MedorException(e.getMessage());
144 }
145 }
146
147 public QueryTree getQueryTree() {
148 return queryTree;
149 }
150
151 public String [] getOutPutDirectoryName() {
152 String [] dirs = new String [2];
153 dirs[0] = sourceDirectory;
154 dirs[1] = classDirectory;
155
156 return dirs;
157 }
158
159
164 private void builtAllFilterSources() throws MedorException {
165 builtFilterSources(queryTree);
166 }
167
168 private void builtAllTCTypeSources() throws MedorException {
169 builtTCTypeSources(queryTree);
170 }
171
172 public void generateTCTypeClass() throws MedorException {
173 builtAllTCTypeSources();
174 }
176
177
181 private void generateTCType(int[] indexes,
182 TupleStructure ts,
183 String javaFileName)
184 throws MedorException, Exception {
185 FileWriter fw = tcTypeHolder.getFileWriter(javaFileName + ".java");
187 byte b = 0;
188 Block bk = new BlockImpl(fw, b);
189 bk.writeLine("/**");
190 bk.writeLine(" * This class is generated by Medor Compilator");
191 bk.writeLine(" * It represents a TupleLoader Object");
192 bk.writeLine(" */");
193 bk.newLine();
194 bk.writeLine("package org.objectweb.medor.query.lib;");
195 bk.newLine();
196 bk.writeLine("import org.objectweb.medor.api.MedorException;");
197 bk.writeLine("import org.objectweb.medor.tuple.api.TupleLoader;");
198 bk.writeLine("import org.objectweb.medor.tuple.api.Tuple;");
199 bk.writeLine("import org.objectweb.medor.filter.api.VariableOperand;");
200 bk.newLine();
201 bk.openBlock("public final class " + javaFileName + " implements TupleLoader");
202 bk.openBlock("public void loadTuple(Tuple thisTuple, VariableOperand[] temp) throws MedorException");
203
204 PType type;
205 int size = indexes.length;
206 for (int i = 0; (i < size); i++) {
207 type = ts.getField(i + 1).getType();
209 if (indexes[i] != -1) {
210 switch (type.getTypeCode()) {
211 case QTypeTuple.TYPECODE_INT:
212 bk.writeLine("temp[" + i + "].setValue(thisTuple.getInt(" + indexes[i] + ");");
213 break;
214 case QTypeTuple.TYPECODE_SHORT:
215 bk.writeLine("temp[" + i + "].setValue(thisTuple.getShort(" + indexes[i] + ");");
216 break;
217 case QTypeTuple.TYPECODE_BYTE:
218 bk.writeLine("temp[" + i + "].setValue(thisTuple.getByte(" + indexes[i] + ");");
219 break;
220 case QTypeTuple.TYPECODE_LONG:
221 bk.writeLine("temp[" + i + "].setValue(thisTuple.getLong(" + indexes[i] + ");");
222 break;
223 case QTypeTuple.TYPECODE_DOUBLE:
224 bk.writeLine("temp[" + i + "].setValue(thisTuple.getDouble(" + indexes[i] + ");");
225 break;
226 case QTypeTuple.TYPECODE_BOOLEAN:
227 bk.writeLine("temp[" + i + "].setValue(thisTuple.getBoolean(" + indexes[i] + ");");
228 break;
229 case QTypeTuple.TYPECODE_FLOAT:
230 bk.writeLine("temp[" + i + "].setValue(thisTuple.getFloat(" + indexes[i] + ");");
231 break;
232 case QTypeTuple.TYPECODE_STRING:
233 bk.writeLine("temp[" + i + "].setValue(thisTuple.getString(" + indexes[i] + "));");
234 break;
235 case QTypeTuple.TYPECODE_CHAR:
236 bk.writeLine("temp[" + i + "].setValue(thisTuple.getChar(" + indexes[i] + ");");
237 break;
238 case QTypeTuple.TYPECODE_DATE:
239 bk.writeLine("temp[" + i + "].setValue(thisTuple.getDate(" + indexes[i] + ");");
240 break;
241 default:
243 if (type.getJormName().equals("collection"))
244 bk.writeLine("temp[" + i + "].setValue(thisTuple.getTupleCollection(" + indexes[i] + ");");
245 break;
246 }
248 } else {
249 Expression calculExp = ((CalculatedField) ts.getField(i + 1)).getExpression();
251 String filterExpression = parserGenerateFiltStringExp(eHelper.toStack(calculExp));
252 bk.writeLine("temp[" + i + "].setValue(" + filterExpression + ");");
253 }
254 }
255 bk.closeBlock();
256 bk.closeBlock();
257 fw.close();
258 }
259
260
264 private void generateFilter(Expression filter, String javaFileName) throws MedorException, Exception {
265
266 FileWriter fw = queryFiltersHolder.getFileWriter(javaFileName + ".java");
268 byte b = 0;
269 Block bk = new BlockImpl(fw, b);
270 bk.writeLine("/**");
271 bk.writeLine(" * This class is generated by Medor Compiler");
272 bk.writeLine(" * It represents a compiled Expression");
273 bk.writeLine(" */");
274 bk.newLine();
275 bk.writeLine("package org.objectweb.medor.filter.lib;"); bk.newLine();
277 bk.writeLine("import org.objectweb.medor.expression.api.MalformedExpressionException;");
278 bk.writeLine("import org.objectweb.medor.filter.api.Expression;");
279 bk.writeLine("import org.objectweb.medor.expression.api.ParameterOperand;");
280 bk.writeLine("import org.objectweb.jorm.type.api.PType;");
281 bk.writeLine("import org.objectweb.medor.type.lib.PTypeSpaceMedor;");
282 bk.writeLine("import org.objectweb.medor.tuple.api.Tuple;");
283 bk.newLine();
284 bk.openBlock("public final class " + javaFileName + " implements Expression");
285 bk.newLine();
286
287 String [] parameters = eHelper.getParameterNames(filter);
288
289 for (int cpt = 0; (cpt < parameters.length); cpt++) {
290 bk.writeLine("public ParameterOperand " + parameters[cpt] + ";");
291 }
292
293 bk.openBlock("public boolean evaluate(ParameterOperand[] parameters,Tuple thisTuple) throws MalformedExpressionException");
294
295 String filterExpression = parserGenerateFiltStringExp(eHelper.toStack(filter));
296
297 bk.writeLine("return " + filterExpression + ";");
298 bk.closeBlock();
299
300 String ptype = "";
301 bk.newLine();
302 bk.openBlock("PType getType()");
303 switch (filter.getType().getTypeCode()) {
304 case QTypeTuple.TYPECODE_BYTE:
305 ptype = "PTypeSpaceMedor.BYTE";
306 break;
307 case QTypeTuple.TYPECODE_DOUBLE:
308 ptype = "PTypeSpaceMedor.DOUBLE";
309 break;
310 case QTypeTuple.TYPECODE_INT:
311 ptype = "PTypeSpaceMedor.INT";
312 break;
313 case QTypeTuple.TYPECODE_FLOAT:
314 ptype = "PTypeSpaceMedor.FLOAT";
315 break;
316 case QTypeTuple.TYPECODE_LONG:
317 ptype = "PTypeSpaceMedor.LONG";
318 break;
319 case QTypeTuple.TYPECODE_SHORT:
320 ptype = "PTypeSpaceMedor.SHORT";
321 break;
322 case QTypeTuple.TYPECODE_BOOLEAN:
323 ptype = "PTypeSpaceMedor.BOOLEAN";
324 break;
325 case QTypeTuple.TYPECODE_CHAR:
326 ptype = "PTypeSpaceMedor.CHAR";
327 break;
328 case QTypeTuple.TYPECODE_DATE:
329 ptype = "PTypeSpaceMedor.DATE";
330 break;
331 }
332 bk.writeLine("return " + ptype + ";");
333 bk.closeBlock();
334
335 bk.newLine();
336 bk.closeBlock();
337 fw.close();
338 }
339
340 private String parserGenerateFiltStringExp(Expression[] regularExp)
341 throws ExpressionException {
342 Object [] polonfpf = regularExp;
343 Stack popBuffer = new Stack ();
344 int cpt = 0;
345 Comparator c;
347 BinaryLogicalOperator bLogicop;
348 BinaryArithmeticOperator bArithOp;
349 Object op1,op2;
350 String leftOp,rightOp,opExp = "";
351 String operator;
352
353 while (cpt < polonfpf.length) {
354 if (polonfpf[cpt] instanceof Operand)
355 popBuffer.push(polonfpf[cpt]);
356 else if (polonfpf[cpt] instanceof Comparator) {
357 op2 = popBuffer.pop();
358 op1 = popBuffer.pop();
359 c = (Comparator) polonfpf[cpt];
360 operator = c.getOperatorString();
361 if (op1 instanceof Operand) {
362 leftOp = getStringOperandExp((Operand) op1);
363 } else
365 leftOp = ((String ) op1);
366
367 if (op2 instanceof Operand) {
368 rightOp = getStringOperandExp((Operand) op2);
369 } else
370 rightOp = ((String ) op2);
371
372 if (!c.getType().isa(PTypeSpace.STRING)) {
373 opExp = "(" + leftOp + operator + rightOp + ")";
374 } else {
375 opExp = "(" + leftOp + "compareTo(" + rightOp + ")" + operator + "0)";
376 }
377 popBuffer.push(opExp);
378
379 } else if (polonfpf[cpt] instanceof BelongOperator) {
380 op2 = popBuffer.pop();
381 op1 = popBuffer.pop();
382
383 if (op1 instanceof Operand) {
384 leftOp = getStringOperandExp((Operand) op1);
385 } else
386 leftOp = ((String ) op1);
387
388 if (op2 instanceof Operand) {
389 rightOp = getStringOperandExp((Operand) op2);
390 } else
391 rightOp = ((String ) op2);
392
393 opExp = "(new InTupleCollection().evaluate(leftOp , rightOp)";
394 popBuffer.push(opExp);
395
396 } else if (polonfpf[cpt] instanceof BinaryLogicalOperator) {
397 op2 = popBuffer.pop();
398 op1 = popBuffer.pop();
399 bLogicop = (BinaryLogicalOperator) polonfpf[cpt];
400 operator = bLogicop.getOperatorString();
401 if (op1 instanceof Operand) {
402 leftOp = getStringOperandExp((Operand) op1);
403 } else
404 leftOp = ((String ) op1);
405
406 if (op2 instanceof Operand) {
407 rightOp = getStringOperandExp((Operand) op2);
408 } else
409 rightOp = ((String ) op2);
410
411 opExp = "(" + leftOp + operator + rightOp + ")";
412 popBuffer.push(opExp);
413
414 } else if (polonfpf[cpt] instanceof UnaryLogicalOperator) {
415 op1 = popBuffer.pop();
416 if (op1 instanceof Operand) {
417 leftOp = getStringOperandExp((Operand) op1);
418 } else
419 leftOp = ((String ) op1);
420
421 opExp = "(!" + leftOp + ")";
422 popBuffer.push(opExp);
423
424 } else if (polonfpf[cpt] instanceof BinaryArithmeticOperator) {
425 op2 = popBuffer.pop();
426 op1 = popBuffer.pop();
427 bArithOp = (BinaryArithmeticOperator) polonfpf[cpt];
428 operator = bArithOp.getOperatorString() + "";
429 if ((op1 instanceof Operand) & (op2 instanceof Operand)) {
430 PType typer = bArithOp.getType();
431 switch (typer.getTypeCode()) {
432 case QTypeTuple.TYPECODE_BYTE:
433 opExp = bArithOp.evaluate(((Operand) op1).getByte(), ((Operand) op2).getByte()) + "";
434 break;
435 case QTypeTuple.TYPECODE_DOUBLE:
436 opExp = bArithOp.evaluate(((Operand) op1).getDouble(), ((Operand) op2).getDouble()) + "";
437 break;
438 case QTypeTuple.TYPECODE_INT:
439 opExp = bArithOp.evaluate(((Operand) op1).getInt(), ((Operand) op2).getInt()) + "";
440 break;
441 case QTypeTuple.TYPECODE_FLOAT:
442 opExp = bArithOp.evaluate(((Operand) op1).getFloat(), ((Operand) op2).getFloat()) + "";
443 break;
444 case QTypeTuple.TYPECODE_LONG:
445 opExp = bArithOp.evaluate(((Operand) op1).getLong(), ((Operand) op2).getLong()) + "";
446 break;
447 case QTypeTuple.TYPECODE_SHORT:
448 opExp = bArithOp.evaluate(((Operand) op1).getShort(), ((Operand) op2).getShort()) + "";
449 break;
450 }
451 } else {
452
453 if (op1 instanceof Operand) {
454 leftOp = getStringOperandExp((Operand) op1);
455 } else
456 leftOp = ((String ) op1);
457
458 if (op2 instanceof Operand) {
459 rightOp = getStringOperandExp((Operand) op2);
460 } else
461 rightOp = ((String ) op2);
462
463 opExp = "(" + leftOp + operator + rightOp + ")";
464 }
465 popBuffer.push(opExp);
466
467 } else if (polonfpf[cpt] instanceof UnaryArithmeticOperator) {
468 UnaryArithmeticOperator unArith = (UnaryArithmeticOperator) polonfpf[cpt];
469 op1 = popBuffer.pop();
470 if (op1 instanceof Operand) {
471 leftOp = getStringOperandExp((Operand) op1);
472 } else
473 leftOp = ((String ) op1);
474
475 opExp = "(" + unArith.getOperatorString() + leftOp + ")";
476 popBuffer.push(opExp);
477 }
478 cpt++;
479 }
480 return (String ) popBuffer.pop();
481 }
482
483 private String getStringOperandExp(Operand op)
484 throws ExpressionException {
485 String operandExp = "";
486 int range;
487 PType type = op.getType();
488 switch (type.getTypeCode()) {
489 case QTypeTuple.TYPECODE_INT:
490 if (op instanceof ParameterOperand) {
491 operandExp = ((ParameterOperand) op).getName() + ".getInt()";
492 } else if (op instanceof FieldOperand) {
493 range = ((FieldOperand) op).getIndex();
494 operandExp = "thisTuple.getInt(" + range + ")";
495 } else
496 operandExp = op.getInt() + "";
497 break;
498 case QTypeTuple.TYPECODE_SHORT:
499 if (op instanceof ParameterOperand) {
500 operandExp = ((ParameterOperand) op).getName() + ".getShort()";
501 } else if (op instanceof Operand)
502 operandExp = op.getShort() + "";
503 else if (op instanceof FieldOperand) {
504 range = ((FieldOperand) op).getIndex();
505 operandExp = "thisTuple.getShort(" + range + ")";
506 }
507 break;
508
509 case QTypeTuple.TYPECODE_DATE:
510 if (op instanceof ParameterOperand) {
511 operandExp = ((ParameterOperand) op).getName() + ".getByte()";
512 } else if (op instanceof Operand)
513 operandExp = op.getByte() + "";
514 else if (op instanceof FieldOperand) {
515 range = ((FieldOperand) op).getIndex();
516 operandExp = "thisTuple.getByte(" + range + ")";
517 }
518 break;
519
520 case QTypeTuple.TYPECODE_LONG:
521 if (op instanceof ParameterOperand) {
522 operandExp = ((ParameterOperand) op).getName() + ".getLong()";
523 } else if (op instanceof Operand)
524 operandExp = op.getLong() + "";
525 else if (op instanceof FieldOperand) {
526 range = ((FieldOperand) op).getIndex();
527 operandExp = "thisTuple.getLong(" + range + ")";
528 }
529 break;
530
531 case QTypeTuple.TYPECODE_DOUBLE:
532 if (op instanceof ParameterOperand) {
533 operandExp = ((ParameterOperand) op).getName() + ".getDouble()";
534 } else if (op instanceof Operand)
535 operandExp = op.getDouble() + "";
536 else if (op instanceof FieldOperand) {
537 range = ((FieldOperand) op).getIndex();
538 operandExp = "thisTuple.getDouble(" + range + ")";
539 }
540 break;
541
542 case QTypeTuple.TYPECODE_FLOAT:
543 if (op instanceof ParameterOperand) {
544 operandExp = ((ParameterOperand) op).getName() + ".getFloat()";
545 } else if (op instanceof Operand)
546 operandExp = op.getFloat() + "";
547 else if (op instanceof FieldOperand) {
548 range = ((FieldOperand) op).getIndex();
549 operandExp = "thisTuple.getFloat(" + range + ")";
550 }
551 break;
552
553 case QTypeTuple.TYPECODE_BOOLEAN:
554 if (op instanceof ParameterOperand) {
555 operandExp = ((ParameterOperand) op).getName() + ".getBoolean()";
556 } else if (op instanceof Operand)
557 operandExp = op.getBoolean() + "";
558 else if (op instanceof FieldOperand) {
559 range = ((FieldOperand) op).getIndex();
560 operandExp = "thisTuple.getBoolean(" + range + ")";
561 }
562 break;
563
564 case QTypeTuple.TYPECODE_CHAR:
565 if (op instanceof ParameterOperand) {
566 operandExp = ((ParameterOperand) op).getName() + ".getChar()";
567 } else if (op instanceof Operand)
568 operandExp = op.getChar() + "";
569 else if (op instanceof FieldOperand) {
570 range = ((FieldOperand) op).getIndex();
571 operandExp = "thisTuple.getChar(" + range + ")";
572 }
573 break;
574
575 case QTypeTuple.TYPECODE_STRING:
576 if (op instanceof ParameterOperand) {
577 operandExp = ((ParameterOperand) op).getName() + ".getString()";
578 } else if (op instanceof Operand)
579 operandExp = op.getString();
580 else if (op instanceof FieldOperand) {
581 range = ((FieldOperand) op).getIndex();
582 operandExp = "thisTuple.getString(" + range + ")";
583 }
584 break;
585
586 default:
587
588 if (type.getJormName().equals("collection")) {
589 if (op instanceof ParameterOperand) {
590 operandExp = ((ParameterOperand) op).getName() + ".getTupleCollection()";
591 } else if (op instanceof Operand)
592 operandExp = op.getObject() + "";
593 else if (op instanceof FieldOperand) {
594 range = ((FieldOperand) op).getIndex();
595 operandExp = "thisTuple.getTupleCollection(" + range + ")";
596 }
597 break;
598 } else if (type.getJormName().equals("tuple")) {
599
600 if (op instanceof ParameterOperand) {
601 operandExp = ((ParameterOperand) op).getName() + ".getTuple()";
602 } else if (op instanceof Operand)
603 operandExp = op.getObject() + "";
604 else if (op instanceof FieldOperand) {
605 range = ((FieldOperand) op).getIndex();
606 operandExp = "thisTuple.getTuple(" + range + ")";
607
608 }
609 break;
610 }
611 }
612
613 return operandExp;
614 }
615
616 public Iterator getSourceFileIterator() {
617 return queryFiltersHolder.iterateFile();
618 }
619
620
624 public QueryTree transform(QueryTree query) throws MedorException {
625 this.queryTree = query;
626 builtAllFilterSources();
630 builtAllTCTypeSources();
631 Vector list = new Vector ();
632 Iterator i1 = queryFiltersHolder.iterateFile();
633 Iterator i2 = tcTypeHolder.iterateFile();
634 while (i1.hasNext()) {
635 list.add(i1.next());
636 }
637 while (i2.hasNext()) {
638 list.add(i2.next());
639 }
640 javac(list.elements());
641 QueryTree copy = queryTree;
643 library.add(sourceDirectory);
644 mcl = new DirsCompileClassLoader(library);
645 nbrFilter = 0;
646 nbrQTType = 0;
647 compileFilters(copy, javaFilterName + nbrFilter);
648 compileQueryTreeType(copy, javaTCTypeFileName + nbrQTType);
649 return copy;
651 }
652
653 private void compileFilters(QueryTree query, String fileName)
654 throws MedorException {
655 Class c = null;
656 try {
657 if ((query instanceof QueryNode) &&
659 (((QueryNode) query).getQueryFilter() != null)) {
660 nbrFilter++;
661 c = mcl.loadClass("org.objectweb.medor.filter.lib.postFixeForm.generated." + fileName);
662 Object o = c.newInstance();
663 Expression predicate = (Expression) o;
664 ((QueryNode) query).setQueryFilter(predicate);
665 QueryTree[] qts = ((QueryNode) query).getChildren();
666
667 for (int cpt = 0; (cpt < qts.length); cpt++) {
668
669 compileFilters(qts[cpt], javaFilterName + nbrFilter);
670
671 }
672 }
673 } catch (ClassNotFoundException exp) {
674 throw new MedorException("THIS CLASS NOT EXIST TRY TO COMPILE AT FIRST");
675 } catch (InstantiationException iexo) {
676 } catch (IllegalAccessException e) {
677 }
678 }
679
680 private void compileQueryTreeType(QueryTree query, String fileName)
681 throws MedorException {
682 Class c = null;
683 try {
684 if ((query instanceof QueryNode) &&
686 ((QueryNode) query).getTupleLoader() != null) {
687 nbrQTType++;
688 c = mcl.loadClass("org.objectweb.medor.query.lib.generated." + fileName);
689 Object o = c.newInstance();
690 TupleLoader tLoader = (TupleLoader) o;
691 ((QueryNode) query).setTupleLoader(tLoader);
692 QueryTree[] qts = ((QueryNode) query).getChildren();
694
695 for (int cpt = 0; (cpt < qts.length); cpt++) {
696 compileQueryTreeType(qts[cpt], javaTCTypeFileName + nbrQTType);
697 }
698 }
699 } catch (ClassNotFoundException exp) {
700 throw new MedorException("THIS CLASS May be NOT EXIST TRY TO COMPILE AT FIRST or correct the classpath");
701 } catch (InstantiationException iexo) {
702 } catch (IllegalAccessException e) {
703 }
704 }
705
706
710 private void javac(Enumeration listFile) {
711
712 Runtime rt = Runtime.getRuntime();
713 Process p;
714 try {
716 System.out.println("Launching javac ...");
717 String classpath = "";
718 String sourceFiles = sourceDirectory + File.separator;
719 Iterator i = library.iterator();
720 if (i.hasNext()) classpath = classpath + ((String ) i.next());
721 while (i.hasNext()) {
722 classpath = classpath + File.pathSeparator + ((String ) i.next());
723 }
724
725 if (listFile.hasMoreElements()) {
726 File f = (File ) listFile.nextElement();
727 String s = f.getName();
728 sourceFiles = sourceFiles + s;
729 }
730
731 while (listFile.hasMoreElements()) {
732 File f = (File ) listFile.nextElement();
733 String s = f.getName();
734 sourceFiles = sourceFiles + " " + sourceDirectory + File.separator + s; }
736
737 String cmd = "javac -classpath " + classpath + " " + "-d " + classDirectory + " " + sourceFiles;
738 System.out.println(cmd);
739 p = rt.exec(cmd);
740 p.waitFor();
741 System.out.println("Compilation finisched ...");
742
743 } catch (IOException e) {
744 System.err.println(" Compilation failed... " + e.getMessage());
745
746 } catch (InterruptedException e) {
747 System.err.println(" Compilation failed... " + e.getMessage());
748 }
749 }
750
751 public void addLibraryPath(String classpath) throws MedorException {
752
753 File tadir = new File (classpath);
754 if (!tadir.exists()) {
755 throw new MedorException("the path library " + classpath + "does not exist");
756 }
757 library.add(classpath);
758 }
759
760 public Iterator getPathsIterator() {
761 return library.iterator();
762 }
763 }
764 |
Popular Tags |
Java API By Example, From Geeks To Geeks.