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 EvaluatedAssignmentProducerNode(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     // ML: add limit, skip!
 130     private final static String   ENUMERATION_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
 131     private final static String   ENUMERATION_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
 132     private final static String   ENUMERATION_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
 133     private final static String   ENUMERATION_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
 134     private final static String   ENUMERATION_DEFAULT_SUBNODE = "default";
 135     private final static String[] ENUMERATION_REQUIRED_ATTRIBUTES = { ENUMERATION_KEY_ATTRIBUTE, ENUMERATION_DEFINITION_ATTRIBUTE };
 136     private final static String[] ENUMERATION_OPTIONAL_ATTRIBUTES = { ENUMERATION_SELECTION_ATTRIBUTE, ENUMERATION_ORDER_ATTRIBUTE};
 137     private final static String[] ENUMERATION_SUBNODES = {ENUMERATION_DEFAULT_SUBNODE};
 138
 139     private String key;
 140     private String definition;
 141     private String selection;
 142     private String order;
 143     private EntityAdapterModel model;
 144
 145     public EnumeratingProducerNodeBuilder(EntityAdapterModel aModel) {
 146       super(ENUMERATION_SUBNODES);
 147
 148       model = aModel;
 149     }
 150
 151     public void setAttributes(Map anAttributes) throws ProducerConfigExc  {
 152       ReaderTool.checkAttributes(anAttributes, ENUMERATION_REQUIRED_ATTRIBUTES, ENUMERATION_OPTIONAL_ATTRIBUTES);
 153
 154       key = (String) anAttributes.get(ENUMERATION_KEY_ATTRIBUTE);
 155       definition = (String) anAttributes.get(ENUMERATION_DEFINITION_ATTRIBUTE);
 156       selection = (String) anAttributes.get(ENUMERATION_SELECTION_ATTRIBUTE);
 157       order = (String) anAttributes.get(ENUMERATION_ORDER_ATTRIBUTE);
 158     };
 159
 160     public ProducerNode constructNode() {
 161       return new EntityEnumeratingProducerNode(key, model, definition, selection, order, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
 162     };
 163
 164     public static class factory implements ProducerNodeBuilderFactory {
 165       private EntityAdapterModel model;
 166
 167       public factory(EntityAdapterModel aModel) {
 168         model = aModel;
 169       }
 170
 171       public ProducerNodeBuilder makeBuilder() {
 172         return new EnumeratingProducerNodeBuilder(model);
 173       }
 174     }
 175   }
 176
 177 ////////////////////////////////////////////////////////////////////////////////
 178
 179   public static class ListProducerNodeBuilder extends AbstractProducerNodeBuilder {
 180     private final static String   LIST_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
 181     private final static String   LIST_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
 182     private final static String   LIST_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
 183     private final static String   LIST_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
 184     private final static String   LIST_DEFAULT_SUBNODE = "default";
 185     private final static String   LIST_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
 186     private final static String   LIST_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
 187     private final static String[] LIST_REQUIRED_ATTRIBUTES = { LIST_KEY_ATTRIBUTE, LIST_DEFINITION_ATTRIBUTE };
 188     private final static String[] LIST_OPTIONAL_ATTRIBUTES = { LIST_SELECTION_ATTRIBUTE, LIST_ORDER_ATTRIBUTE, LIST_SKIP_ATTRIBUTE, LIST_LIMIT_ATTRIBUTE};
 189     private final static String[] LIST_SUBNODES = {LIST_DEFAULT_SUBNODE};
 190
 191     private String key;
 192     private String definition;
 193     private String selection;
 194     private String order;
 195     private int limit;
 196     private int skip;
 197     private EntityAdapterModel model;
 198
 199     public ListProducerNodeBuilder(EntityAdapterModel aModel) {
 200       super(LIST_SUBNODES);
 201
 202       model = aModel;
 203     }
 204
 205     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 206       String limitString;
 207       String skipString;
 208
 209       ReaderTool.checkAttributes(anAttributes, LIST_REQUIRED_ATTRIBUTES, LIST_OPTIONAL_ATTRIBUTES);
 210
 211       key = (String) anAttributes.get(LIST_KEY_ATTRIBUTE);
 212       definition = (String) anAttributes.get(LIST_DEFINITION_ATTRIBUTE);
 213       selection = (String) anAttributes.get(LIST_SELECTION_ATTRIBUTE);
 214       order = (String) anAttributes.get(LIST_ORDER_ATTRIBUTE);
 215       skip = 0;
 216       limit = -1;
 217
 218       limitString = (String) anAttributes.get(LIST_LIMIT_ATTRIBUTE);
 219       if (limitString!=null) {
 220         try {
 221           limit = Integer.parseInt(limitString);
 222         }
 223         catch (Throwable t) {
 224           throw new ProducerConfigExc("invalid value for list parameter: " + limitString);
 225         }
 226       }
 227       skipString = (String) anAttributes.get(LIST_SKIP_ATTRIBUTE);
 228       if (skipString!=null) {
 229         try {
 230           skip = Integer.parseInt(skipString);
 231         }
 232         catch (Throwable t) {
 233           throw new ProducerConfigExc("invalid value for skip parameter: " + skipString);
 234         }
 235       }
 236     };
 237
 238     public ProducerNode constructNode() {
 239       return new EntityListProducerNode(key, model, definition, selection, order, limit, skip, getSubNode(LIST_DEFAULT_SUBNODE ));
 240     };
 241
 242     public static class factory implements ProducerNodeBuilderFactory {
 243       private EntityAdapterModel model;
 244
 245       public factory(EntityAdapterModel aModel) {
 246         model = aModel;
 247       }
 248
 249       public ProducerNodeBuilder makeBuilder() {
 250         return new ListProducerNodeBuilder(model);
 251       }
 252     }
 253   }
 254
 255 ////////////////////////////////////////////////////////////////////////////////
 256
 257   public static class LoggingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 258     private final static String   LOG_MESSAGE_ATTRIBUTE = "message";
 259     private final static String[] LOG_REQUIRED_ATTRIBUTES = { LOG_MESSAGE_ATTRIBUTE };
 260     private final static String[] LOG_OPTIONAL_ATTRIBUTES = {};
 261     private final static String[] LOG_SUBNODES = {};
 262
 263     private String message;
 264
 265     public LoggingProducerNodeBuilder() {
 266       super(LOG_SUBNODES);
 267     }
 268
 269     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 270       ReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES);
 271
 272       message = (String) anAttributes.get(LOG_MESSAGE_ATTRIBUTE);
 273     };
 274
 275     public ProducerNode constructNode() {
 276       return new LoggingProducerNode(message);
 277     };
 278   }
 279
 280 ////////////////////////////////////////////////////////////////////////////////
 281
 282   public static class ResourceBundleProducerNodeBuilder extends AbstractProducerNodeBuilder {
 283     private final static String   RESOURCEBUNDLE_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
 284     private final static String   RESOURCEBUNDLE_BUNDLE_ATTRIBUTE = "bundle";
 285     private final static String   RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE = "language";
 286     private final static String   RESOURCEBUNDLE_DEFAULT_SUBNODE = "default";
 287     private final static String[] RESOURCEBUNDLE_REQUIRED_ATTRIBUTES = { RESOURCEBUNDLE_KEY_ATTRIBUTE, RESOURCEBUNDLE_BUNDLE_ATTRIBUTE };
 288     private final static String[] RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES = { RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE};
 289     private final static String[] RESOURCEBUNDLE_SUBNODES = {RESOURCEBUNDLE_DEFAULT_SUBNODE};
 290
 291     private String key;
 292     private String bundle;
 293     private String language;
 294
 295     public ResourceBundleProducerNodeBuilder() {
 296       super(RESOURCEBUNDLE_SUBNODES);
 297     }
 298
 299     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 300       ReaderTool.checkAttributes(anAttributes, RESOURCEBUNDLE_REQUIRED_ATTRIBUTES, RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES);
 301
 302       key = (String) anAttributes.get(RESOURCEBUNDLE_KEY_ATTRIBUTE);
 303       bundle = (String) anAttributes.get(RESOURCEBUNDLE_BUNDLE_ATTRIBUTE);
 304       language = (String) anAttributes.get(RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE);
 305     };
 306
 307     public ProducerNode constructNode() {
 308       return new ResourceBundleProducerNode(key, bundle, language, getSubNode(RESOURCEBUNDLE_DEFAULT_SUBNODE ));
 309     };
 310   }
 311
 312 ////////////////////////////////////////////////////////////////////////////////
 313
 314   public static class FileDateSettingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 315     private final static String   FILEDATESETTING_FILE_ATTRIBUTE = "filename";
 316     private final static String   FILEDATESETTING_DATE_ATTRIBUTE = "date";
 317     private final static String[] FILEDATESETTING_REQUIRED_ATTRIBUTES = { FILEDATESETTING_FILE_ATTRIBUTE, FILEDATESETTING_DATE_ATTRIBUTE };
 318     private final static String[] FILEDATESETTING_OPTIONAL_ATTRIBUTES = { };
 319     private final static String[] FILEDATESETTING_SUBNODES = {};
 320
 321     private String fileNameKey;
 322     private String dateKey;
 323
 324     public FileDateSettingProducerNodeBuilder() {
 325       super(FILEDATESETTING_SUBNODES);
 326     }
 327
 328     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 329       ReaderTool.checkAttributes(anAttributes, FILEDATESETTING_REQUIRED_ATTRIBUTES, FILEDATESETTING_OPTIONAL_ATTRIBUTES);
 330
 331       fileNameKey = (String) anAttributes.get(FILEDATESETTING_FILE_ATTRIBUTE);
 332       dateKey = (String) anAttributes.get(FILEDATESETTING_DATE_ATTRIBUTE);
 333     };
 334
 335     public ProducerNode constructNode() {
 336       return new FileDateSettingProducerNode(fileNameKey, dateKey);
 337     };
 338   }
 339
 340 ////////////////////////////////////////////////////////////////////////////////
 341
 342   public static class FileDeletingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 343     private final static String   FILEDELETING_FILE_ATTRIBUTE = "filename";
 344     private final static String[] FILEDELETING_REQUIRED_ATTRIBUTES = { FILEDELETING_FILE_ATTRIBUTE };
 345     private final static String[] FILEDELETING_OPTIONAL_ATTRIBUTES = { };
 346     private final static String[] FILEDELETING_SUBNODES = { };
 347
 348     private String fileNameKey;
 349
 350     public FileDeletingProducerNodeBuilder() {
 351       super(FILEDELETING_SUBNODES);
 352     }
 353
 354     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 355       ReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES);
 356
 357       fileNameKey = (String) anAttributes.get(FILEDELETING_FILE_ATTRIBUTE);
 358     };
 359
 360     public ProducerNode constructNode() {
 361       return new FileDeletingProducerNode(fileNameKey);
 362     };
 363   }
 364
 365 ////////////////////////////////////////////////////////////////////////////////
 366
 367   public static class ScriptCallingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 368     private final static String   SCRIPT_COMMAND_ATTRIBUTE = "command";
 369     private final static String[] SCRIPT_REQUIRED_ATTRIBUTES = { SCRIPT_COMMAND_ATTRIBUTE };
 370     private final static String[] SCRIPT_OPTIONAL_ATTRIBUTES = {};
 371     private final static String[] SCRIPT_SUBNODES = {};
 372
 373     private String command;
 374
 375     public ScriptCallingProducerNodeBuilder() {
 376       super(SCRIPT_SUBNODES);
 377     }
 378
 379     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 380       ReaderTool.checkAttributes(anAttributes, SCRIPT_REQUIRED_ATTRIBUTES, SCRIPT_OPTIONAL_ATTRIBUTES);
 381
 382       command = (String) anAttributes.get(SCRIPT_COMMAND_ATTRIBUTE);
 383     };
 384
 385     public ProducerNode constructNode() {
 386       return new ScriptCallingProducerNode(command);
 387     };
 388   }
 389
 390 ////////////////////////////////////////////////////////////////////////////////
 391
 392   public static class GeneratingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 393     private final static String   GENERATION_GENERATOR_ATTRIBUTE = "generator";
 394     private final static String   GENERATION_DESTINATION_ATTRIBUTE = "destination";
 395     private final static String   GENERATION_PARAMETERS_ATTRIBUTE = "parameters";
 396     private final static String[] GENERATION_REQUIRED_ATTRIBUTES = { GENERATION_GENERATOR_ATTRIBUTE, GENERATION_DESTINATION_ATTRIBUTE };
 397     private final static String[] GENERATION_OPTIONAL_ATTRIBUTES = { GENERATION_PARAMETERS_ATTRIBUTE};
 398     private final static String[] GENERATION_SUBNODES = {};
 399
 400     private String generator;
 401     private String destination;
 402     private String parameters;
 403     private Generator.GeneratorLibrary generatorLibrary;
 404     private WriterEngine writerEngine;
 405
 406     public GeneratingProducerNodeBuilder(Generator.GeneratorLibrary aGeneratorLibrary, WriterEngine aWriterEngine) {
 407       super(GENERATION_SUBNODES);
 408
 409       writerEngine = aWriterEngine;
 410       generatorLibrary = aGeneratorLibrary;
 411     }
 412
 413     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 414       ReaderTool.checkAttributes(anAttributes, GENERATION_REQUIRED_ATTRIBUTES, GENERATION_OPTIONAL_ATTRIBUTES);
 415
 416       generator = (String) anAttributes.get(GENERATION_GENERATOR_ATTRIBUTE);
 417       destination = (String) anAttributes.get(GENERATION_DESTINATION_ATTRIBUTE);
 418       parameters = ReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" );
 419     };
 420
 421     public ProducerNode constructNode() {
 422       return new GeneratingProducerNode(generatorLibrary, writerEngine, generator, destination, parameters);
 423     };
 424
 425     public static class factory implements ProducerNodeBuilderFactory {
 426       private Generator.GeneratorLibrary generatorLibrary;
 427       private WriterEngine writerEngine;
 428
 429       public factory(Generator.GeneratorLibrary aGeneratorLibrary, WriterEngine aWriterEngine) {
 430         writerEngine = aWriterEngine;
 431         generatorLibrary = aGeneratorLibrary;
 432       }
 433
 434       public ProducerNodeBuilder makeBuilder() {
 435         return new GeneratingProducerNodeBuilder(generatorLibrary, writerEngine);
 436       }
 437     }
 438   }
 439
 440 ////////////////////////////////////////////////////////////////////////////////
 441
 442   public static class BatchingProducerNodeBuilder extends AbstractProducerNodeBuilder {
 443
 444     private final static String   BATCHER_DATAKEY_ATTRIBUTE = KEY_ATTRIBUTE;
 445     private final static String   BATCHER_INFOKEY_ATTRIBUTE = "infokey";
 446     private final static String   BATCHER_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
 447     private final static String   BATCHER_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
 448     private final static String   BATCHER_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
 449
 450     private final static String   BATCHER_BATCHSIZE_ATTRIBUTE = "batchsize";
 451     private final static String   BATCHER_MINBATCHSIZE_ATTRIBUTE = "minbatchsize";
 452     private final static String   BATCHER_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
 453
 454     private final static String   BATCHER_BATCH_SUBNODE = "batches";
 455     private final static String   BATCHER_BATCHLIST_SUBNODE = "batchlist";
 456     private final static String[] BATCHER_REQUIRED_ATTRIBUTES = { BATCHER_DATAKEY_ATTRIBUTE, BATCHER_INFOKEY_ATTRIBUTE, BATCHER_DEFINITION_ATTRIBUTE, BATCHER_BATCHSIZE_ATTRIBUTE };
 457     private final static String[] BATCHER_OPTIONAL_ATTRIBUTES = { BATCHER_SELECTION_ATTRIBUTE, BATCHER_ORDER_ATTRIBUTE, BATCHER_MINBATCHSIZE_ATTRIBUTE, BATCHER_SKIP_ATTRIBUTE };
 458     private final static String[] BATCHER_SUBNODES = { BATCHER_BATCH_SUBNODE, BATCHER_BATCHLIST_SUBNODE };
 459
 460     private EntityAdapterModel model;
 461     private String batchDataKey;
 462     private String batchInfoKey;
 463     private String definition;
 464     private String selection;
 465     private String order;
 466     private int batchSize;
 467     private int minBatchSize;
 468     private int skip;
 469
 470
 471     public BatchingProducerNodeBuilder(EntityAdapterModel aModel) {
 472       super(BATCHER_SUBNODES);
 473
 474       model = aModel;
 475     }
 476
 477     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 478       ReaderTool.checkAttributes(anAttributes, BATCHER_REQUIRED_ATTRIBUTES, BATCHER_OPTIONAL_ATTRIBUTES);
 479
 480       batchDataKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DATAKEY_ATTRIBUTE, "data" );
 481       batchInfoKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_INFOKEY_ATTRIBUTE, "info" );
 482       definition = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DEFINITION_ATTRIBUTE, "" );
 483       selection = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SELECTION_ATTRIBUTE, "" );
 484       order = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_ORDER_ATTRIBUTE, "" );
 485
 486       batchSize = ReaderTool.getIntegerAttributeWithDefault(anAttributes, BATCHER_BATCHSIZE_ATTRIBUTE, 20 );
 487       minBatchSize = ReaderTool.getIntegerAttributeWithDefault(anAttributes, BATCHER_MINBATCHSIZE_ATTRIBUTE, 0 );
 488       skip = ReaderTool.getIntegerAttributeWithDefault(anAttributes, BATCHER_SKIP_ATTRIBUTE, 0 );
 489     };
 490
 491     public ProducerNode constructNode() {
 492       return new EntityBatchingProducerNode(
 493           batchDataKey,
 494           batchInfoKey,
 495           model,
 496           definition,
 497           selection,
 498           order,
 499           batchSize,
 500           minBatchSize,
 501           skip,
 502           getSubNode( BATCHER_BATCH_SUBNODE ),
 503           getSubNode( BATCHER_BATCHLIST_SUBNODE )
 504       );
 505     };
 506
 507     public static class factory implements ProducerNodeBuilderFactory {
 508       private EntityAdapterModel model;
 509
 510       public factory(EntityAdapterModel aModel) {
 511         model = aModel;
 512       }
 513
 514       public ProducerNodeBuilder makeBuilder() {
 515         return new BatchingProducerNodeBuilder(model);
 516       }
 517     }
 518   }
 519
 520 ////////////////////////////////////////////////////////////////////////////////
 521
 522   public static class ConditionalProducerNodeBuilder extends AbstractProducerNodeBuilder {
 523     private final static String   IF_CONDITION_ATTRIBUTE = "condition";
 524
 525     private final static String   IF_TRUE_SUBNODE = "then";
 526     private final static String   IF_FALSE_SUBNODE = "else";
 527     private final static String[] IF_REQUIRED_ATTRIBUTES = { IF_CONDITION_ATTRIBUTE };
 528     private final static String[] IF_OPTIONAL_ATTRIBUTES = {  };
 529     private final static String[] IF_SUBNODES = { IF_TRUE_SUBNODE, IF_FALSE_SUBNODE };
 530
 531     private String condition;
 532
 533     public ConditionalProducerNodeBuilder() {
 534       super(IF_SUBNODES);
 535     }
 536
 537     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 538       ReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES);
 539
 540       condition = (String) anAttributes.get( IF_CONDITION_ATTRIBUTE );
 541     };
 542
 543     public ProducerNode constructNode() {
 544       return new ConditionalProducerNode(
 545           condition,
 546           getSubNode( IF_TRUE_SUBNODE ),
 547           getSubNode( IF_FALSE_SUBNODE )
 548       );
 549     };
 550
 551   }
 552
 553 ////////////////////////////////////////////////////////////////////////////////
 554
 555   public static class ScriptedProducerNodeBuilder implements ProducerNodeBuilder {
 556     private ScriptedProducerNodeDefinition definition;
 557     private Map nodeParameterValues;
 558     private Map parameterValues;
 559
 560     public ScriptedProducerNodeBuilder(ScriptedProducerNodeDefinition aDefinition) {
 561       definition = aDefinition;
 562
 563       parameterValues = new HashMap();
 564       parameterValues.putAll(definition.getParameters());
 565
 566       nodeParameterValues = new HashMap();
 567     }
 568
 569     public void setSubNode(String aName, ProducerNode aNode) {
 570       nodeParameterValues.put(aName, aNode);
 571     };
 572
 573     public Set getAvailableSubNodes() {
 574       return definition.getNodeParameters();
 575     };
 576
 577     public void setAttributes(Map anAttributes) throws ProducerConfigExc {
 578       ReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes());
 579     };
 580
 581     public ProducerNode constructNode() {
 582       return new ScriptedProducerNode(definition, parameterValues, nodeParameterValues);
 583     };
 584
 585     public static class factory implements ProducerNodeBuilderFactory {
 586       private ScriptedProducerNodeDefinition definition;
 587
 588       public factory(ScriptedProducerNodeDefinition aDefinition) {
 589         definition = aDefinition;
 590       }
 591
 592       public ProducerNodeBuilder makeBuilder() {
 593         return new ScriptedProducerNodeBuilder(definition);
 594       }
 595     }
 596   }
 597 }