source/mir/producer/reader/DefaultProducerNodeBuilders.java

   1 package mir.producer.reader;
   2
   3 import java.util.*;
   4 import mir.generator.*;
   5 import mir.producer.*;
   6 import mir.entity.adapter.*;
   7 import mir.util.*;
   8
   9 public class DefaultProducerNodeBuilders {
  10
  11   public static void registerBuilders(ProducerNodeBuilderLibrary aBuilderLibrary,
  12        EntityAdapterModel aModel, Generator.GeneratorLibrary aGeneratorLibrary,
  13        WriterEngine aWriterEngine) {
  14
  15     aBuilderLibrary.registerBuilder("Set", EvaluatedAssignmentProducerNodeBuilder.class);
  16     aBuilderLibrary.registerBuilder("Define", ExpandedAssignmentProducerNodeBuilder.class);
  17     aBuilderLibrary.registerBuilder("Log", LoggingProducerNodeBuilder.class);
  18     aBuilderLibrary.registerBuilder("Execute", ScriptCallingProducerNodeBuilder.class);
  19     aBuilderLibrary.registerBuilder("Resource", ResourceBundleProducerNodeBuilder.class);
  20
  21     aBuilderLibrary.registerBuilder("DeleteFile", FileDeletingProducerNodeBuilder.class);
  22     aBuilderLibrary.registerBuilder("SetFileDate", FileDateSettingProducerNodeBuilder.class);
  23     aBuilderLibrary.registerBuilder("If", ConditionalProducerNodeBuilder.class);
  24
  25
  26     aBuilderLibrary.registerFactory("Enumerate", new EnumeratingProducerNodeBuilder.factory(aModel));
  27     aBuilderLibrary.registerFactory("List", new ListProducerNodeBuilder.factory(aModel));
  28     aBuilderLibrary.registerFactory("Batch", new BatchingProducerNodeBuilder.factory(aModel));
  29
  30     aBuilderLibrary.registerFactory("Generate",
  31         new GeneratingProducerNodeBuilder.factory(aGeneratorLibrary, aWriterEngine));
  32   }
  33
  34   public static abstract class AbstractProducerNodeBuilder implements ProducerNodeBuilder {
  35     private Map attributes;
  36     private Map subNodes;
  37     private Set availableSubnodes;
  38
  39     public AbstractProducerNodeBuilder(String anAvailableSubNodes[]) {
  40       attributes = new HashMap();
  41       subNodes = new HashMap();
  42       availableSubnodes = new HashSet(Arrays.asList(anAvailableSubNodes));
  43     }
  44
  45     protected ProducerNode getSubNode(String aName) {
  46       return (ProducerNode) subNodes.get(aName);
  47     }
  48
  49     public void setSubNode(String aName, ProducerNode aNode) {
  50       subNodes.put(aName, aNode);
  51     };
  52
  53     public Set getAvailableSubNodes() {
  54       return availableSubnodes;
  55     };
  56   }
  57
  58 ////////////////////////////////////////////////////////////////////////////////
  59
  60   // general attribute names, specifc builders reference these, to keep attribute
  61   //    names consistent
  62
  63   public final static String   SELECTION_ATTRIBUTE = "selection";
  64   public final static String   ORDER_ATTRIBUTE = "order";
  65   public final static String   DEFINITION_ATTRIBUTE = "table";
  66   public final static String   SKIP_ATTRIBUTE = "skip";
  67   public final static String   KEY_ATTRIBUTE = "key";
  68   public final static String   LIMIT_ATTRIBUTE = "limit";
  69
  70 ////////////////////////////////////////////////////////////////////////////////
  71
  72   public static class ExpandedAssignmentProducerNodeBuilder extends AbstractProducerNodeBuilder {
  73     private final static String   ASSIGNMENT_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
  74     private final static String   ASSIGNMENT_VALUE_ATTRIBUTE = "value";
  75     private final static String[] ASSIGNMENT_REQUIRED_ATTRIBUTES = { ASSIGNMENT_KEY_ATTRIBUTE, ASSIGNMENT_VALUE_ATTRIBUTE };
  76     private final static String[] ASSIGNMENT_OPTIONAL_ATTRIBUTES = {};
  77     private final static String[] ASSIGNMENT_SUBNODES = {};
  78
  79     private String key;
  80     private String value;
  81
  82     public ExpandedAssignmentProducerNodeBuilder() {
  83       super(ASSIGNMENT_SUBNODES);
  84     }
  85
  86     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
  87       ReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
  88
  89       key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
  90       value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
  91     };
  92
  93     public ProducerNode constructNode() {
  94       return new ExpandedAssignmentProducerNode(key, value);
  95     };
  96   }
  97
  98 ////////////////////////////////////////////////////////////////////////////////
  99
 100   public static class EvaluatedAssignmentProducerNodeBuilder extends AbstractProducerNodeBuilder {
 101     private final static String   ASSIGNMENT_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
 102     private final static String   ASSIGNMENT_VALUE_ATTRIBUTE = "value";
 103     private final static String[] ASSIGNMENT_REQUIRED_ATTRIBUTES = { ASSIGNMENT_KEY_ATTRIBUTE, ASSIGNMENT_VALUE_ATTRIBUTE };
 104     private final static String[] ASSIGNMENT_OPTIONAL_ATTRIBUTES = {};
 105     private final static String[] ASSIGNMENT_SUBNODES = {};
 106
 107     private String key;
 108     private String value;
 109
 110     public EvaluatedAssignmentProducerNodeBuilder() {
 111       super(ASSIGNMENT_SUBNODES);
 112     }
 113
 114     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 115       ReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
 116
 117       key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
 118       value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
 119     };
 120
 121     public ProducerNode constructNode() {
 122       return new EvaluatedAssignmentProducerNode(key, value);
 123     };
 124   }
 125
 126 ////////////////////////////////////////////////////////////////////////////////
 127
 128   public static class EnumeratingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 129     private final static String   ENUMERATION_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
 130     private final static String   ENUMERATION_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
 131     private final static String   ENUMERATION_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
 132     private final static String   ENUMERATION_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
 133     private final static String   ENUMERATION_DEFAULT_SUBNODE = "default";
 134     private final static String   ENUMERATION_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
 135     private final static String   ENUMERATION_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
 136     private final static String[] ENUMERATION_REQUIRED_ATTRIBUTES = { ENUMERATION_KEY_ATTRIBUTE, ENUMERATION_DEFINITION_ATTRIBUTE };
 137     private final static String[] ENUMERATION_OPTIONAL_ATTRIBUTES = { ENUMERATION_SELECTION_ATTRIBUTE, ENUMERATION_ORDER_ATTRIBUTE, ENUMERATION_LIMIT_ATTRIBUTE, ENUMERATION_SKIP_ATTRIBUTE};
 138     private final static String[] ENUMERATION_SUBNODES = {ENUMERATION_DEFAULT_SUBNODE};
 139
 140     private String key;
 141     private String definition;
 142     private String selection;
 143     private String order;
 144     private String limit;
 145     private String skip;
 146     private EntityAdapterModel model;
 147
 148     public EnumeratingProducerNodeBuilder(EntityAdapterModel aModel) {
 149       super(ENUMERATION_SUBNODES);
 150
 151       model = aModel;
 152     }
 153
 154     public void setAttributes(Map anAttributes) throws ProducerConfigExc  {
 155       ReaderTool.checkAttributes(anAttributes, ENUMERATION_REQUIRED_ATTRIBUTES, ENUMERATION_OPTIONAL_ATTRIBUTES);
 156
 157       key = (String) anAttributes.get(ENUMERATION_KEY_ATTRIBUTE);
 158       definition = (String) anAttributes.get(ENUMERATION_DEFINITION_ATTRIBUTE);
 159       selection = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_SELECTION_ATTRIBUTE, "");
 160       order = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_ORDER_ATTRIBUTE, "");
 161       limit = (String) anAttributes.get(ENUMERATION_LIMIT_ATTRIBUTE);
 162       skip = (String) anAttributes.get(ENUMERATION_SKIP_ATTRIBUTE);
 163     };
 164
 165     public ProducerNode constructNode() {
 166       return new EntityEnumeratingProducerNode(key, model, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
 167     };
 168
 169     public static class factory implements ProducerNodeBuilderFactory {
 170       private EntityAdapterModel model;
 171
 172       public factory(EntityAdapterModel aModel) {
 173         model = aModel;
 174       }
 175
 176       public ProducerNodeBuilder makeBuilder() {
 177         return new EnumeratingProducerNodeBuilder(model);
 178       }
 179     }
 180   }
 181
 182 ////////////////////////////////////////////////////////////////////////////////
 183
 184   public static class ListProducerNodeBuilder extends AbstractProducerNodeBuilder {
 185     private final static String   LIST_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
 186     private final static String   LIST_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
 187     private final static String   LIST_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
 188     private final static String   LIST_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
 189     private final static String   LIST_DEFAULT_SUBNODE = "default";
 190     private final static String   LIST_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
 191     private final static String   LIST_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
 192     private final static String[] LIST_REQUIRED_ATTRIBUTES = { LIST_KEY_ATTRIBUTE, LIST_DEFINITION_ATTRIBUTE };
 193     private final static String[] LIST_OPTIONAL_ATTRIBUTES = { LIST_SELECTION_ATTRIBUTE, LIST_ORDER_ATTRIBUTE, LIST_SKIP_ATTRIBUTE, LIST_LIMIT_ATTRIBUTE};
 194     private final static String[] LIST_SUBNODES = {};
 195
 196     private String key;
 197     private String definition;
 198     private String selection;
 199     private String order;
 200     private String limit;
 201     private String skip;
 202     private EntityAdapterModel model;
 203
 204     public ListProducerNodeBuilder(EntityAdapterModel aModel) {
 205       super(LIST_SUBNODES);
 206
 207       model = aModel;
 208     }
 209
 210     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 211       ReaderTool.checkAttributes(anAttributes, LIST_REQUIRED_ATTRIBUTES, LIST_OPTIONAL_ATTRIBUTES);
 212
 213       key = (String) anAttributes.get(LIST_KEY_ATTRIBUTE);
 214       definition = (String) anAttributes.get(LIST_DEFINITION_ATTRIBUTE);
 215       selection = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, LIST_SELECTION_ATTRIBUTE, "");
 216       order = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, LIST_ORDER_ATTRIBUTE, "");
 217       limit = (String) anAttributes.get(LIST_LIMIT_ATTRIBUTE);
 218       skip = (String) anAttributes.get(LIST_SKIP_ATTRIBUTE);
 219     };
 220
 221     public ProducerNode constructNode() {
 222       return new EntityListProducerNode(key, model, definition, selection, order, limit, skip, null );
 223     };
 224
 225     public static class factory implements ProducerNodeBuilderFactory {
 226       private EntityAdapterModel model;
 227
 228       public factory(EntityAdapterModel aModel) {
 229         model = aModel;
 230       }
 231
 232       public ProducerNodeBuilder makeBuilder() {
 233         return new ListProducerNodeBuilder(model);
 234       }
 235     }
 236   }
 237
 238 ////////////////////////////////////////////////////////////////////////////////
 239
 240   public static class LoggingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 241     private final static String   LOG_MESSAGE_ATTRIBUTE = "message";
 242     private final static String[] LOG_REQUIRED_ATTRIBUTES = { LOG_MESSAGE_ATTRIBUTE };
 243     private final static String[] LOG_OPTIONAL_ATTRIBUTES = {};
 244     private final static String[] LOG_SUBNODES = {};
 245
 246     private String message;
 247
 248     public LoggingProducerNodeBuilder() {
 249       super(LOG_SUBNODES);
 250     }
 251
 252     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 253       ReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES);
 254
 255       message = (String) anAttributes.get(LOG_MESSAGE_ATTRIBUTE);
 256     };
 257
 258     public ProducerNode constructNode() {
 259       return new LoggingProducerNode(message);
 260     };
 261   }
 262
 263 ////////////////////////////////////////////////////////////////////////////////
 264
 265   public static class ResourceBundleProducerNodeBuilder extends AbstractProducerNodeBuilder {
 266     private final static String   RESOURCEBUNDLE_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
 267     private final static String   RESOURCEBUNDLE_BUNDLE_ATTRIBUTE = "bundle";
 268     private final static String   RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE = "language";
 269     private final static String   RESOURCEBUNDLE_DEFAULT_SUBNODE = "default";
 270     private final static String[] RESOURCEBUNDLE_REQUIRED_ATTRIBUTES = { RESOURCEBUNDLE_KEY_ATTRIBUTE, RESOURCEBUNDLE_BUNDLE_ATTRIBUTE };
 271     private final static String[] RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES = { RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE};
 272     private final static String[] RESOURCEBUNDLE_SUBNODES = {};
 273
 274     private String key;
 275     private String bundle;
 276     private String language;
 277
 278     public ResourceBundleProducerNodeBuilder() {
 279       super(RESOURCEBUNDLE_SUBNODES);
 280     }
 281
 282     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 283       ReaderTool.checkAttributes(anAttributes, RESOURCEBUNDLE_REQUIRED_ATTRIBUTES, RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES);
 284
 285       key = (String) anAttributes.get(RESOURCEBUNDLE_KEY_ATTRIBUTE);
 286       bundle = (String) anAttributes.get(RESOURCEBUNDLE_BUNDLE_ATTRIBUTE);
 287       language = (String) anAttributes.get(RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE);
 288     };
 289
 290     public ProducerNode constructNode() {
 291       return new ResourceBundleProducerNode(key, bundle, language, null );
 292     };
 293   }
 294
 295 ////////////////////////////////////////////////////////////////////////////////
 296
 297   public static class FileDateSettingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 298     private final static String   FILEDATESETTING_FILE_ATTRIBUTE = "filename";
 299     private final static String   FILEDATESETTING_DATE_ATTRIBUTE = "date";
 300     private final static String[] FILEDATESETTING_REQUIRED_ATTRIBUTES = { FILEDATESETTING_FILE_ATTRIBUTE, FILEDATESETTING_DATE_ATTRIBUTE };
 301     private final static String[] FILEDATESETTING_OPTIONAL_ATTRIBUTES = { };
 302     private final static String[] FILEDATESETTING_SUBNODES = {};
 303
 304     private String fileNameKey;
 305     private String dateKey;
 306
 307     public FileDateSettingProducerNodeBuilder() {
 308       super(FILEDATESETTING_SUBNODES);
 309     }
 310
 311     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 312       ReaderTool.checkAttributes(anAttributes, FILEDATESETTING_REQUIRED_ATTRIBUTES, FILEDATESETTING_OPTIONAL_ATTRIBUTES);
 313
 314       fileNameKey = (String) anAttributes.get(FILEDATESETTING_FILE_ATTRIBUTE);
 315       dateKey = (String) anAttributes.get(FILEDATESETTING_DATE_ATTRIBUTE);
 316     };
 317
 318     public ProducerNode constructNode() {
 319       return new FileDateSettingProducerNode(fileNameKey, dateKey);
 320     };
 321   }
 322
 323 ////////////////////////////////////////////////////////////////////////////////
 324
 325   public static class FileDeletingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 326     private final static String   FILEDELETING_FILE_ATTRIBUTE = "filename";
 327     private final static String[] FILEDELETING_REQUIRED_ATTRIBUTES = { FILEDELETING_FILE_ATTRIBUTE };
 328     private final static String[] FILEDELETING_OPTIONAL_ATTRIBUTES = { };
 329     private final static String[] FILEDELETING_SUBNODES = { };
 330
 331     private String fileNameKey;
 332
 333     public FileDeletingProducerNodeBuilder() {
 334       super(FILEDELETING_SUBNODES);
 335     }
 336
 337     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 338       ReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES);
 339
 340       fileNameKey = (String) anAttributes.get(FILEDELETING_FILE_ATTRIBUTE);
 341     };
 342
 343     public ProducerNode constructNode() {
 344       return new FileDeletingProducerNode(fileNameKey);
 345     };
 346   }
 347
 348 ////////////////////////////////////////////////////////////////////////////////
 349
 350   public static class ScriptCallingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 351     private final static String   SCRIPT_COMMAND_ATTRIBUTE = "command";
 352     private final static String[] SCRIPT_REQUIRED_ATTRIBUTES = { SCRIPT_COMMAND_ATTRIBUTE };
 353     private final static String[] SCRIPT_OPTIONAL_ATTRIBUTES = {};
 354     private final static String[] SCRIPT_SUBNODES = {};
 355
 356     private String command;
 357
 358     public ScriptCallingProducerNodeBuilder() {
 359       super(SCRIPT_SUBNODES);
 360     }
 361
 362     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 363       ReaderTool.checkAttributes(anAttributes, SCRIPT_REQUIRED_ATTRIBUTES, SCRIPT_OPTIONAL_ATTRIBUTES);
 364
 365       command = (String) anAttributes.get(SCRIPT_COMMAND_ATTRIBUTE);
 366     };
 367
 368     public ProducerNode constructNode() {
 369       return new ScriptCallingProducerNode(command);
 370     };
 371   }
 372
 373 ////////////////////////////////////////////////////////////////////////////////
 374
 375   public static class GeneratingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 376     private final static String   GENERATION_GENERATOR_ATTRIBUTE = "generator";
 377     private final static String   GENERATION_DESTINATION_ATTRIBUTE = "destination";
 378     private final static String   GENERATION_PARAMETERS_ATTRIBUTE = "parameters";
 379     private final static String[] GENERATION_REQUIRED_ATTRIBUTES = { GENERATION_GENERATOR_ATTRIBUTE, GENERATION_DESTINATION_ATTRIBUTE };
 380     private final static String[] GENERATION_OPTIONAL_ATTRIBUTES = { GENERATION_PARAMETERS_ATTRIBUTE};
 381     private final static String[] GENERATION_SUBNODES = {};
 382
 383     private String generator;
 384     private String destination;
 385     private String parameters;
 386     private Generator.GeneratorLibrary generatorLibrary;
 387     private WriterEngine writerEngine;
 388
 389     public GeneratingProducerNodeBuilder(Generator.GeneratorLibrary aGeneratorLibrary, WriterEngine aWriterEngine) {
 390       super(GENERATION_SUBNODES);
 391
 392       writerEngine = aWriterEngine;
 393       generatorLibrary = aGeneratorLibrary;
 394     }
 395
 396     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 397       ReaderTool.checkAttributes(anAttributes, GENERATION_REQUIRED_ATTRIBUTES, GENERATION_OPTIONAL_ATTRIBUTES);
 398
 399       generator = (String) anAttributes.get(GENERATION_GENERATOR_ATTRIBUTE);
 400       destination = (String) anAttributes.get(GENERATION_DESTINATION_ATTRIBUTE);
 401       parameters = ReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" );
 402     };
 403
 404     public ProducerNode constructNode() {
 405       return new GeneratingProducerNode(generatorLibrary, writerEngine, generator, destination, parameters);
 406     };
 407
 408     public static class factory implements ProducerNodeBuilderFactory {
 409       private Generator.GeneratorLibrary generatorLibrary;
 410       private WriterEngine writerEngine;
 411
 412       public factory(Generator.GeneratorLibrary aGeneratorLibrary, WriterEngine aWriterEngine) {
 413         writerEngine = aWriterEngine;
 414         generatorLibrary = aGeneratorLibrary;
 415       }
 416
 417       public ProducerNodeBuilder makeBuilder() {
 418         return new GeneratingProducerNodeBuilder(generatorLibrary, writerEngine);
 419       }
 420     }
 421   }
 422
 423 ////////////////////////////////////////////////////////////////////////////////
 424
 425   public static class BatchingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 426
 427     private final static String   BATCHER_DATAKEY_ATTRIBUTE = KEY_ATTRIBUTE;
 428     private final static String   BATCHER_INFOKEY_ATTRIBUTE = "infokey";
 429     private final static String   BATCHER_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
 430     private final static String   BATCHER_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
 431     private final static String   BATCHER_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
 432
 433     private final static String   BATCHER_BATCHSIZE_ATTRIBUTE = "batchsize";
 434     private final static String   BATCHER_MINBATCHSIZE_ATTRIBUTE = "minbatchsize";
 435     private final static String   BATCHER_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
 436
 437     private final static String   BATCHER_PROCESS_ATTRIBUTE = "process";
 438
 439     private final static String   BATCHER_BATCH_SUBNODE = "batches";
 440     private final static String   BATCHER_BATCHLIST_SUBNODE = "batchlist";
 441     private final static String[] BATCHER_REQUIRED_ATTRIBUTES = { BATCHER_DATAKEY_ATTRIBUTE, BATCHER_INFOKEY_ATTRIBUTE, BATCHER_DEFINITION_ATTRIBUTE, BATCHER_BATCHSIZE_ATTRIBUTE };
 442     private final static String[] BATCHER_OPTIONAL_ATTRIBUTES = { BATCHER_SELECTION_ATTRIBUTE, BATCHER_ORDER_ATTRIBUTE, BATCHER_MINBATCHSIZE_ATTRIBUTE, BATCHER_SKIP_ATTRIBUTE, BATCHER_PROCESS_ATTRIBUTE };
 443     private final static String[] BATCHER_SUBNODES = { BATCHER_BATCH_SUBNODE, BATCHER_BATCHLIST_SUBNODE };
 444
 445     // ML: batchSize, minBatchSize, skip should be expressions!
 446
 447     private EntityAdapterModel model;
 448     private String batchDataKey;
 449     private String batchInfoKey;
 450     private String definition;
 451     private String selection;
 452     private String order;
 453     private String batchSize;
 454     private String minBatchSize;
 455     private String skip;
 456     private String process;
 457
 458     public BatchingProducerNodeBuilder(EntityAdapterModel aModel) {
 459       super(BATCHER_SUBNODES);
 460
 461       model = aModel;
 462     }
 463
 464     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 465       ReaderTool.checkAttributes(anAttributes, BATCHER_REQUIRED_ATTRIBUTES, BATCHER_OPTIONAL_ATTRIBUTES);
 466
 467       batchDataKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DATAKEY_ATTRIBUTE, "data" );
 468       batchInfoKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_INFOKEY_ATTRIBUTE, "info" );
 469       definition = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DEFINITION_ATTRIBUTE, "" );
 470       selection = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SELECTION_ATTRIBUTE, "" );
 471       order = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_ORDER_ATTRIBUTE, "" );
 472
 473       batchSize = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_BATCHSIZE_ATTRIBUTE, "20" );
 474       minBatchSize = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_MINBATCHSIZE_ATTRIBUTE, "0" );
 475       skip = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SKIP_ATTRIBUTE, "0" );
 476       process = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_PROCESS_ATTRIBUTE, "-1" );
 477     };
 478
 479     public ProducerNode constructNode() {
 480       return new EntityBatchingProducerNode(
 481           batchDataKey,
 482           batchInfoKey,
 483           model,
 484           definition,
 485           selection,
 486           order,
 487           batchSize,
 488           minBatchSize,
 489           skip,
 490           process,
 491           getSubNode( BATCHER_BATCH_SUBNODE ),
 492           getSubNode( BATCHER_BATCHLIST_SUBNODE )
 493       );
 494     };
 495
 496     public static class factory implements ProducerNodeBuilderFactory {
 497       private EntityAdapterModel model;
 498
 499       public factory(EntityAdapterModel aModel) {
 500         model = aModel;
 501       }
 502
 503       public ProducerNodeBuilder makeBuilder() {
 504         return new BatchingProducerNodeBuilder(model);
 505       }
 506     }
 507   }
 508
 509 ////////////////////////////////////////////////////////////////////////////////
 510
 511   public static class ConditionalProducerNodeBuilder extends AbstractProducerNodeBuilder {
 512     private final static String   IF_CONDITION_ATTRIBUTE = "condition";
 513
 514     private final static String   IF_TRUE_SUBNODE = "then";
 515     private final static String   IF_FALSE_SUBNODE = "else";
 516     private final static String[] IF_REQUIRED_ATTRIBUTES = { IF_CONDITION_ATTRIBUTE };
 517     private final static String[] IF_OPTIONAL_ATTRIBUTES = {  };
 518     private final static String[] IF_SUBNODES = { IF_TRUE_SUBNODE, IF_FALSE_SUBNODE };
 519
 520     private String condition;
 521
 522     public ConditionalProducerNodeBuilder() {
 523       super(IF_SUBNODES);
 524     }
 525
 526     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 527       ReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES);
 528
 529       condition = (String) anAttributes.get( IF_CONDITION_ATTRIBUTE );
 530     };
 531
 532     public ProducerNode constructNode() {
 533       return new ConditionalProducerNode(
 534           condition,
 535           getSubNode( IF_TRUE_SUBNODE ),
 536           getSubNode( IF_FALSE_SUBNODE )
 537       );
 538     };
 539
 540   }
 541
 542 ////////////////////////////////////////////////////////////////////////////////
 543
 544   public static class ScriptedProducerParameterNodeBuilder implements ProducerNodeBuilder {
 545     private String parameterName;
 546     private String scriptedNodeName;
 547
 548     public ScriptedProducerParameterNodeBuilder(String aScriptedNodeName, String aParameterName) {
 549       parameterName = aParameterName;
 550       scriptedNodeName = aScriptedNodeName;
 551     }
 552
 553     public void setSubNode(String aName, ProducerNode aNode) {
 554     };
 555
 556     public Set getAvailableSubNodes() {
 557       return new HashSet();
 558     };
 559
 560     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 561       if (!anAttributes.isEmpty())
 562         throw new ProducerConfigExc("No parameters allowed here");
 563     };
 564
 565     public ProducerNode constructNode() {
 566       return new ScriptedProducerNodeDefinition.NodeParameterProducerNode(scriptedNodeName, parameterName);
 567     };
 568   }
 569
 570 ////////////////////////////////////////////////////////////////////////////////
 571
 572   public static class ScriptedProducerNodeBuilder implements ProducerNodeBuilder {
 573     private ScriptedProducerNodeDefinition definition;
 574     private Map nodeParameterValues;
 575     private Map parameterValues;
 576
 577     public ScriptedProducerNodeBuilder(ScriptedProducerNodeDefinition aDefinition) {
 578       definition = aDefinition;
 579
 580       parameterValues = new HashMap();
 581       parameterValues.putAll(definition.getParameters());
 582
 583       nodeParameterValues = new HashMap();
 584     }
 585
 586     public void setSubNode(String aName, ProducerNode aNode) {
 587       nodeParameterValues.put(aName, aNode);
 588     };
 589
 590     public Set getAvailableSubNodes() {
 591       return definition.getNodeParameters();
 592     };
 593
 594     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 595       ReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes());
 596     };
 597
 598     public ProducerNode constructNode() {
 599       return new ScriptedProducerNode(definition, parameterValues, nodeParameterValues);
 600     };
 601
 602     public static class factory implements ProducerNodeBuilderFactory {
 603       private ScriptedProducerNodeDefinition definition;
 604
 605       public factory(ScriptedProducerNodeDefinition aDefinition) {
 606         definition = aDefinition;
 607       }
 608
 609       public ProducerNodeBuilder makeBuilder() {
 610         return new ScriptedProducerNodeBuilder(definition);
 611       }
 612     }
 613   }
 614 }