+/*
+ * Copyright (C) 2001, 2002 The Mir-coders group
+ *
+ * This file is part of Mir.
+ *
+ * Mir is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Mir is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Mir; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * In addition, as a special exception, The Mir-coders gives permission to link
+ * the code of this program with any library licensed under the Apache Software License,
+ * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
+ * (or with modified versions of the above that use the same license as the above),
+ * and distribute linked combinations including the two. You must obey the
+ * GNU General Public License in all respects for all of the code used other than
+ * the above mentioned libraries. If you modify this file, you may extend this
+ * exception to your version of the file, but you are not obligated to do so.
+ * If you do not wish to do so, delete this exception statement from your version.
+ */
package mir.producer.reader;
-import java.util.*;
-import mir.generator.*;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import mir.entity.adapter.EntityAdapterModel;
+import mir.generator.Generator;
+import mir.generator.WriterEngine;
+import mir.log.LoggerWrapper;
+import mir.producer.ConditionalProducerNode;
+import mir.producer.DirCopyingProducerNode;
+import mir.producer.EntityBatchingProducerNode;
+import mir.producer.EntityEnumeratingProducerNode;
+import mir.producer.EntityListProducerNode;
+import mir.producer.EvaluatedAssignmentProducerNode;
import mir.producer.*;
-import mir.entity.adapter.*;
-import mir.util.*;
+import mir.producer.FileDateSettingProducerNode;
+import mir.producer.FileDeletingProducerNode;
+import mir.producer.GeneratingProducerNode;
+import mir.producer.LoggingProducerNode;
+import mir.producer.LoopProducerNode;
+import mir.producer.ProducerNode;
+import mir.producer.*;
+import mir.producer.ResourceBundleProducerNode;
+import mir.producer.ScriptCallingProducerNode;
+import mir.util.XMLReader;
+import mir.util.XMLReaderTool;
public class DefaultProducerNodeBuilders {
public static void registerBuilders(ProducerNodeBuilderLibrary aBuilderLibrary,
EntityAdapterModel aModel, Generator.GeneratorLibrary aGeneratorLibrary,
- WriterEngine aWriterEngine) {
+ WriterEngine aWriterEngine, String aSourceBasePath, String aDestinationBasePath) throws ProducerConfigExc {
aBuilderLibrary.registerBuilder("Set", EvaluatedAssignmentProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("Define", ExpandedAssignmentProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("Log", LoggingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("Execute", ScriptCallingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("Resource", ResourceBundleProducerNodeBuilder.class);
+ aBuilderLibrary.registerFactory("CopyDir", new DirCopyProducerNodeBuilder.factory( aSourceBasePath, aDestinationBasePath));
aBuilderLibrary.registerBuilder("DeleteFile", FileDeletingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("SetFileDate", FileDateSettingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("If", ConditionalProducerNodeBuilder.class);
+ aBuilderLibrary.registerBuilder("While", LoopProducerNodeBuilder.class);
+
+ aBuilderLibrary.registerBuilder("RSS", RSSProducerNodeBuilder.class);
+ aBuilderLibrary.registerBuilder("RDFAggregate", RDFAggregatorProducerNodeBuilder.class);
+ aBuilderLibrary.registerBuilder("FreeQuery", FreeQueryProducerNodeBuilder.class);
aBuilderLibrary.registerFactory("Enumerate", new EnumeratingProducerNodeBuilder.factory(aModel));
aBuilderLibrary.registerFactory("List", new ListProducerNodeBuilder.factory(aModel));
aBuilderLibrary.registerFactory("Batch", new BatchingProducerNodeBuilder.factory(aModel));
+ aBuilderLibrary.registerFactory("UpdateEntity", new UpdateEntityProducerNodeBuilder.factory(aModel));
+ aBuilderLibrary.registerFactory("CreateEntity", new CreateEntityProducerNodeBuilder.factory(aModel));
+
aBuilderLibrary.registerFactory("Generate",
new GeneratingProducerNodeBuilder.factory(aGeneratorLibrary, aWriterEngine));
}
public final static String SKIP_ATTRIBUTE = "skip";
public final static String KEY_ATTRIBUTE = "key";
public final static String LIMIT_ATTRIBUTE = "limit";
+ public final static String URL_ATTRIBUTE = "url";
////////////////////////////////////////////////////////////////////////////////
+ private final static String ASSIGNMENT_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
+ private final static String ASSIGNMENT_VALUE_ATTRIBUTE = "value";
+ private final static String[] ASSIGNMENT_REQUIRED_ATTRIBUTES = { ASSIGNMENT_KEY_ATTRIBUTE, ASSIGNMENT_VALUE_ATTRIBUTE };
+ private final static String[] ASSIGNMENT_OPTIONAL_ATTRIBUTES = {};
+ private final static String[] ASSIGNMENT_SUBNODES = {};
+
public static class ExpandedAssignmentProducerNodeBuilder extends AbstractProducerNodeBuilder {
- private final static String ASSIGNMENT_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
- private final static String ASSIGNMENT_VALUE_ATTRIBUTE = "value";
- private final static String[] ASSIGNMENT_REQUIRED_ATTRIBUTES = { ASSIGNMENT_KEY_ATTRIBUTE, ASSIGNMENT_VALUE_ATTRIBUTE };
- private final static String[] ASSIGNMENT_OPTIONAL_ATTRIBUTES = {};
- private final static String[] ASSIGNMENT_SUBNODES = {};
private String key;
private String value;
super(ASSIGNMENT_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
////////////////////////////////////////////////////////////////////////////////
public static class EvaluatedAssignmentProducerNodeBuilder extends AbstractProducerNodeBuilder {
- private final static String ASSIGNMENT_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
- private final static String ASSIGNMENT_VALUE_ATTRIBUTE = "value";
- private final static String[] ASSIGNMENT_REQUIRED_ATTRIBUTES = { ASSIGNMENT_KEY_ATTRIBUTE, ASSIGNMENT_VALUE_ATTRIBUTE };
- private final static String[] ASSIGNMENT_OPTIONAL_ATTRIBUTES = {};
- private final static String[] ASSIGNMENT_SUBNODES = {};
private String key;
private String value;
super(ASSIGNMENT_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, ASSIGNMENT_REQUIRED_ATTRIBUTES, ASSIGNMENT_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
public static class EnumeratingProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String ENUMERATION_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
private final static String ENUMERATION_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
+ private final static String ENUMERATION_LIST_ATTRIBUTE = "list";
private final static String ENUMERATION_SELECTION_ATTRIBUTE = SELECTION_ATTRIBUTE;
private final static String ENUMERATION_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
private final static String ENUMERATION_DEFAULT_SUBNODE = "default";
private final static String ENUMERATION_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
private final static String ENUMERATION_SKIP_ATTRIBUTE = SKIP_ATTRIBUTE;
- private final static String[] ENUMERATION_REQUIRED_ATTRIBUTES = { ENUMERATION_KEY_ATTRIBUTE, ENUMERATION_DEFINITION_ATTRIBUTE };
- private final static String[] ENUMERATION_OPTIONAL_ATTRIBUTES = { ENUMERATION_SELECTION_ATTRIBUTE, ENUMERATION_ORDER_ATTRIBUTE, ENUMERATION_LIMIT_ATTRIBUTE, ENUMERATION_SKIP_ATTRIBUTE};
+ private final static String[] ENUMERATION_LIST_REQUIRED_ATTRIBUTES = { ENUMERATION_LIST_ATTRIBUTE, ENUMERATION_KEY_ATTRIBUTE };
+ private final static String[] ENUMERATION_LIST_OPTIONAL_ATTRIBUTES = { };
+ private final static String[] ENUMERATION_QUERY_REQUIRED_ATTRIBUTES = { ENUMERATION_DEFINITION_ATTRIBUTE, ENUMERATION_KEY_ATTRIBUTE };
+ private final static String[] ENUMERATION_QUERY_OPTIONAL_ATTRIBUTES = { ENUMERATION_SELECTION_ATTRIBUTE, ENUMERATION_ORDER_ATTRIBUTE, ENUMERATION_LIMIT_ATTRIBUTE, ENUMERATION_SKIP_ATTRIBUTE};
private final static String[] ENUMERATION_SUBNODES = {ENUMERATION_DEFAULT_SUBNODE};
private String key;
private String definition;
+ private String list;
private String selection;
private String order;
private String limit;
model = aModel;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, ENUMERATION_REQUIRED_ATTRIBUTES, ENUMERATION_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ definition = (String) anAttributes.get(ENUMERATION_DEFINITION_ATTRIBUTE);
+ list = (String) anAttributes.get(ENUMERATION_LIST_ATTRIBUTE);
+
+ if ((list==null && definition==null) || (list!=null && definition!=null))
+ throw new ProducerConfigExc("Exactly one of "+ENUMERATION_DEFINITION_ATTRIBUTE+" and "+ENUMERATION_LIST_ATTRIBUTE+" must be set");
+
+
+ if (list!=null)
+ XMLReaderTool.checkAttributes(anAttributes, ENUMERATION_LIST_REQUIRED_ATTRIBUTES, ENUMERATION_LIST_OPTIONAL_ATTRIBUTES);
+ if (definition!=null)
+ XMLReaderTool.checkAttributes(anAttributes, ENUMERATION_QUERY_REQUIRED_ATTRIBUTES, ENUMERATION_QUERY_OPTIONAL_ATTRIBUTES);
+
key = (String) anAttributes.get(ENUMERATION_KEY_ATTRIBUTE);
- definition = (String) anAttributes.get(ENUMERATION_DEFINITION_ATTRIBUTE);
- selection = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_SELECTION_ATTRIBUTE, "");
- order = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_ORDER_ATTRIBUTE, "");
+ selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_SELECTION_ATTRIBUTE, "");
+ order = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, ENUMERATION_ORDER_ATTRIBUTE, "");
limit = (String) anAttributes.get(ENUMERATION_LIMIT_ATTRIBUTE);
skip = (String) anAttributes.get(ENUMERATION_SKIP_ATTRIBUTE);
};
public ProducerNode constructNode() {
- return new EntityEnumeratingProducerNode(key, model, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
+ if (definition!=null)
+ return new EntityEnumeratingProducerNode(key, model, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
+ else
+ return new ListEnumeratingProducerNode(key, list, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
};
public static class factory implements ProducerNodeBuilderFactory {
////////////////////////////////////////////////////////////////////////////////
+ public static class UpdateEntityProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String UPDATE_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
+ private final static String UPDATE_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
+ private final static String[] UPDATE_SUBNODES = {};
+
+ private String key;
+ private String definition;
+ private Map fieldValues;
+
+ private EntityAdapterModel model;
+
+ public UpdateEntityProducerNodeBuilder(EntityAdapterModel aModel) {
+ super(UPDATE_SUBNODES);
+
+ model = aModel;
+ fieldValues = new HashMap();
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ key = (String) anAttributes.get(UPDATE_KEY_ATTRIBUTE);
+
+ if (key == null)
+ throw new XMLReader.XMLReaderExc("missing required attribute '" + UPDATE_KEY_ATTRIBUTE + "'" );
+ definition = (String) anAttributes.get(UPDATE_DEFINITION_ATTRIBUTE);
+
+ fieldValues.putAll(anAttributes);
+ fieldValues.remove(UPDATE_KEY_ATTRIBUTE);
+ fieldValues.remove(UPDATE_DEFINITION_ATTRIBUTE);
+ };
+
+ public ProducerNode constructNode() {
+ return new EntityModifyingProducerNode(model, false, definition, key, fieldValues);
+ };
+
+ public static class factory implements ProducerNodeBuilderFactory {
+ private EntityAdapterModel model;
+
+ public factory(EntityAdapterModel aModel) {
+ model = aModel;
+ }
+
+ public ProducerNodeBuilder makeBuilder() {
+ return new UpdateEntityProducerNodeBuilder(model);
+ }
+ }
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
+ public static class CreateEntityProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String CREATEENTITY_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
+ private final static String CREATEENTITY_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
+ private final static String[] CREATEENTITY_SUBNODES = {};
+
+ private String key;
+ private String definition;
+ private Map fieldValues;
+
+ private EntityAdapterModel model;
+
+ public CreateEntityProducerNodeBuilder(EntityAdapterModel aModel) {
+ super(CREATEENTITY_SUBNODES);
+
+ model = aModel;
+ fieldValues = new HashMap();
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ key = (String) anAttributes.get(CREATEENTITY_KEY_ATTRIBUTE);
+ definition = (String) anAttributes.get(CREATEENTITY_DEFINITION_ATTRIBUTE);
+
+ if (key == null)
+ throw new XMLReader.XMLReaderExc("missing required attribute '" + CREATEENTITY_KEY_ATTRIBUTE + "'" );
+ if (definition == null)
+ throw new XMLReader.XMLReaderExc("missing required attribute '" + CREATEENTITY_DEFINITION_ATTRIBUTE + "'" );
+
+ fieldValues.putAll(anAttributes);
+ fieldValues.remove(CREATEENTITY_KEY_ATTRIBUTE);
+ fieldValues.remove(CREATEENTITY_DEFINITION_ATTRIBUTE);
+ };
+
+ public ProducerNode constructNode() {
+ return new EntityModifyingProducerNode(model, true, definition, key, fieldValues);
+ };
+
+ public static class factory implements ProducerNodeBuilderFactory {
+ private EntityAdapterModel model;
+
+ public factory(EntityAdapterModel aModel) {
+ model = aModel;
+ }
+
+ public ProducerNodeBuilder makeBuilder() {
+ return new CreateEntityProducerNodeBuilder(model);
+ }
+ }
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
+ public static class LoopProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String LOOP_CONDITION_ATTRIBUTE = "condition";
+ private final static String LOOP_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
+ private final static String LOOP_DEFAULT_SUBNODE = "default";
+ private final static String[] LOOP_REQUIRED_ATTRIBUTES = { LOOP_CONDITION_ATTRIBUTE };
+ private final static String[] LOOP_OPTIONAL_ATTRIBUTES = { LOOP_LIMIT_ATTRIBUTE };
+ private final static String[] LOOP_SUBNODES = {LOOP_DEFAULT_SUBNODE};
+
+ private String condition;
+ private String limit;
+
+ public LoopProducerNodeBuilder() {
+ super(LOOP_SUBNODES);
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, LOOP_REQUIRED_ATTRIBUTES, LOOP_OPTIONAL_ATTRIBUTES);
+
+ condition = (String) anAttributes.get(LOOP_CONDITION_ATTRIBUTE);
+ limit = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LOOP_LIMIT_ATTRIBUTE, "");
+ };
+
+ public ProducerNode constructNode() {
+ return new LoopProducerNode(condition, limit, getSubNode( LOOP_DEFAULT_SUBNODE ));
+ };
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
public static class ListProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String LIST_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
private final static String LIST_DEFINITION_ATTRIBUTE = DEFINITION_ATTRIBUTE;
model = aModel;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, LIST_REQUIRED_ATTRIBUTES, LIST_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, LIST_REQUIRED_ATTRIBUTES, LIST_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(LIST_KEY_ATTRIBUTE);
definition = (String) anAttributes.get(LIST_DEFINITION_ATTRIBUTE);
- selection = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, LIST_SELECTION_ATTRIBUTE, "");
- order = (String) ReaderTool.getStringAttributeWithDefault(anAttributes, LIST_ORDER_ATTRIBUTE, "");
+ selection = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_SELECTION_ATTRIBUTE, "");
+ order = (String) XMLReaderTool.getStringAttributeWithDefault(anAttributes, LIST_ORDER_ATTRIBUTE, "");
limit = (String) anAttributes.get(LIST_LIMIT_ATTRIBUTE);
skip = (String) anAttributes.get(LIST_SKIP_ATTRIBUTE);
};
public static class LoggingProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String LOG_MESSAGE_ATTRIBUTE = "message";
+ private final static String LOG_TYPE_ATTRIBUTE = "type";
private final static String[] LOG_REQUIRED_ATTRIBUTES = { LOG_MESSAGE_ATTRIBUTE };
- private final static String[] LOG_OPTIONAL_ATTRIBUTES = {};
+ private final static String[] LOG_OPTIONAL_ATTRIBUTES = { LOG_TYPE_ATTRIBUTE };
private final static String[] LOG_SUBNODES = {};
private String message;
+ private int type = LoggerWrapper.INFO_MESSAGE;
public LoggingProducerNodeBuilder() {
super(LOG_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ String typeString;
+
+ XMLReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES);
message = (String) anAttributes.get(LOG_MESSAGE_ATTRIBUTE);
+ if (anAttributes.containsKey(LOG_TYPE_ATTRIBUTE)) {
+ typeString = ((String) anAttributes.get( LOG_TYPE_ATTRIBUTE ));
+
+ if (typeString.toLowerCase().equals("debug"))
+ type = LoggerWrapper.DEBUG_MESSAGE;
+ else if (typeString.toLowerCase().equals("info"))
+ type = LoggerWrapper.INFO_MESSAGE;
+ else if (typeString.toLowerCase().equals("error"))
+ type = LoggerWrapper.ERROR_MESSAGE;
+ else if (typeString.toLowerCase().equals("warning"))
+ type = LoggerWrapper.WARN_MESSAGE;
+ else if (typeString.toLowerCase().equals("fatal"))
+ type = LoggerWrapper.FATAL_MESSAGE;
+ else
+ throw new ProducerConfigExc("unknown log type: " + typeString + " (allowed are debug, info, warning, error, fatal)");
+ }
+ else
+ type = LoggerWrapper.INFO_MESSAGE;
+ };
+
+ public ProducerNode constructNode() {
+ return new LoggingProducerNode(message, type);
+ };
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
+ public static class FreeQueryProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String FREEQUERY_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
+ private final static String FREEQUERY_LIMIT_ATTRIBUTE = LIMIT_ATTRIBUTE;
+ private final static String FREEQUERY_QUERY_ATTRIBUTE = "query";
+ private final static String FREEQUERY_TYPE_ATTRIBUTE = "type";
+ private final static String[] FREEQUERY_REQUIRED_ATTRIBUTES = { KEY_ATTRIBUTE, FREEQUERY_QUERY_ATTRIBUTE };
+ private final static String[] FREEQUERY_OPTIONAL_ATTRIBUTES = { LIMIT_ATTRIBUTE, FREEQUERY_TYPE_ATTRIBUTE };
+ private final static String[] FREEQUERY_SUBNODES = {};
+
+ private String key;
+ private String query;
+ private String limit;
+ private int type;
+
+ public FreeQueryProducerNodeBuilder() {
+ super(FREEQUERY_SUBNODES);
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ String typeString;
+
+ XMLReaderTool.checkAttributes(anAttributes, FREEQUERY_REQUIRED_ATTRIBUTES, FREEQUERY_OPTIONAL_ATTRIBUTES);
+
+ key = (String) anAttributes.get(FREEQUERY_KEY_ATTRIBUTE);
+ query = (String) anAttributes.get(FREEQUERY_QUERY_ATTRIBUTE);
+ limit = (String) anAttributes.get(FREEQUERY_LIMIT_ATTRIBUTE);
+
+ if (anAttributes.containsKey(FREEQUERY_TYPE_ATTRIBUTE)) {
+ typeString = ((String) anAttributes.get( FREEQUERY_TYPE_ATTRIBUTE ));
+
+ if (typeString.toLowerCase().equals("set"))
+ type = FreeQueryProducerNode.QUERY_TYPE_SET;
+ else if (typeString.toLowerCase().equals("row"))
+ type = FreeQueryProducerNode.QUERY_TYPE_ROW;
+ else if (typeString.toLowerCase().equals("value"))
+ type = FreeQueryProducerNode.QUERY_TYPE_VALUE;
+ else
+ throw new ProducerConfigExc("unknown query type: " + typeString + " (allowed are set, row and value)");
+ }
+ else
+ type = FreeQueryProducerNode.QUERY_TYPE_SET;
};
public ProducerNode constructNode() {
- return new LoggingProducerNode(message);
+ return new FreeQueryProducerNode(key, query, limit, type);
};
}
super(RESOURCEBUNDLE_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, RESOURCEBUNDLE_REQUIRED_ATTRIBUTES, RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, RESOURCEBUNDLE_REQUIRED_ATTRIBUTES, RESOURCEBUNDLE_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(RESOURCEBUNDLE_KEY_ATTRIBUTE);
bundle = (String) anAttributes.get(RESOURCEBUNDLE_BUNDLE_ATTRIBUTE);
};
public ProducerNode constructNode() {
- return new ResourceBundleProducerNode(key, bundle, language, null );
+ return new ResourceBundleProducerNode(key, bundle, language);
};
}
super(FILEDATESETTING_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, FILEDATESETTING_REQUIRED_ATTRIBUTES, FILEDATESETTING_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, FILEDATESETTING_REQUIRED_ATTRIBUTES, FILEDATESETTING_OPTIONAL_ATTRIBUTES);
fileNameKey = (String) anAttributes.get(FILEDATESETTING_FILE_ATTRIBUTE);
dateKey = (String) anAttributes.get(FILEDATESETTING_DATE_ATTRIBUTE);
super(FILEDELETING_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES);
fileNameKey = (String) anAttributes.get(FILEDELETING_FILE_ATTRIBUTE);
};
super(SCRIPT_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, SCRIPT_REQUIRED_ATTRIBUTES, SCRIPT_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, SCRIPT_REQUIRED_ATTRIBUTES, SCRIPT_OPTIONAL_ATTRIBUTES);
command = (String) anAttributes.get(SCRIPT_COMMAND_ATTRIBUTE);
};
////////////////////////////////////////////////////////////////////////////////
+ private final static String DIRCOPY_SOURCE_ATTRIBUTE = "source";
+ private final static String DIRCOPY_DESTINATION_ATTRIBUTE = "destination";
+ private final static String[] DIRCOPY_REQUIRED_ATTRIBUTES = { DIRCOPY_SOURCE_ATTRIBUTE, DIRCOPY_DESTINATION_ATTRIBUTE };
+ private final static String[] DIRCOPY_OPTIONAL_ATTRIBUTES = {};
+ private final static String[] DIRCOPY_SUBNODES = {};
+
+ public static class DirCopyProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private String source;
+ private String destination;
+ private String sourceBasePath;
+ private String destinationBasePath;
+
+ public DirCopyProducerNodeBuilder(String aSourceBasePath, String aDestinationBasePath) {
+ super(DIRCOPY_SUBNODES);
+
+ sourceBasePath = aSourceBasePath;
+ destinationBasePath = aDestinationBasePath;
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, DIRCOPY_REQUIRED_ATTRIBUTES, DIRCOPY_OPTIONAL_ATTRIBUTES);
+
+ source = (String) anAttributes.get(DIRCOPY_SOURCE_ATTRIBUTE);
+ destination = (String) anAttributes.get(DIRCOPY_DESTINATION_ATTRIBUTE);
+ };
+
+ public ProducerNode constructNode() {
+ return new DirCopyingProducerNode(sourceBasePath, destinationBasePath, source, destination);
+ };
+
+ public static class factory implements ProducerNodeBuilderFactory {
+ private String sourceBasePath;
+ private String destinationBasePath;
+
+ public factory(String aSourceBasePath, String aDestinationBasePath) {
+ sourceBasePath = aSourceBasePath;
+ destinationBasePath = aDestinationBasePath;
+ }
+
+ public ProducerNodeBuilder makeBuilder() {
+ return new DirCopyProducerNodeBuilder(sourceBasePath, destinationBasePath);
+ }
+ }
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
public static class GeneratingProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String GENERATION_GENERATOR_ATTRIBUTE = "generator";
private final static String GENERATION_DESTINATION_ATTRIBUTE = "destination";
generatorLibrary = aGeneratorLibrary;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, GENERATION_REQUIRED_ATTRIBUTES, GENERATION_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, GENERATION_REQUIRED_ATTRIBUTES, GENERATION_OPTIONAL_ATTRIBUTES);
generator = (String) anAttributes.get(GENERATION_GENERATOR_ATTRIBUTE);
destination = (String) anAttributes.get(GENERATION_DESTINATION_ATTRIBUTE);
- parameters = ReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" );
+ parameters = XMLReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" );
};
public ProducerNode constructNode() {
model = aModel;
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, BATCHER_REQUIRED_ATTRIBUTES, BATCHER_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, BATCHER_REQUIRED_ATTRIBUTES, BATCHER_OPTIONAL_ATTRIBUTES);
- batchDataKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DATAKEY_ATTRIBUTE, "data" );
- batchInfoKey = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_INFOKEY_ATTRIBUTE, "info" );
- definition = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DEFINITION_ATTRIBUTE, "" );
- selection = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SELECTION_ATTRIBUTE, "" );
- order = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_ORDER_ATTRIBUTE, "" );
+ batchDataKey = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DATAKEY_ATTRIBUTE, "data" );
+ batchInfoKey = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_INFOKEY_ATTRIBUTE, "info" );
+ definition = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_DEFINITION_ATTRIBUTE, "" );
+ selection = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SELECTION_ATTRIBUTE, "" );
+ order = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_ORDER_ATTRIBUTE, "" );
- batchSize = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_BATCHSIZE_ATTRIBUTE, "20" );
- minBatchSize = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_MINBATCHSIZE_ATTRIBUTE, "0" );
- skip = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SKIP_ATTRIBUTE, "0" );
- process = ReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_PROCESS_ATTRIBUTE, "-1" );
+ batchSize = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_BATCHSIZE_ATTRIBUTE, "20" );
+ minBatchSize = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_MINBATCHSIZE_ATTRIBUTE, "0" );
+ skip = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SKIP_ATTRIBUTE, "0" );
+ process = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_PROCESS_ATTRIBUTE, "-1" );
};
public ProducerNode constructNode() {
super(IF_SUBNODES);
}
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES);
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES);
condition = (String) anAttributes.get( IF_CONDITION_ATTRIBUTE );
};
////////////////////////////////////////////////////////////////////////////////
+ public static class RSSProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String RSS_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
+ private final static String RSS_URL_ATTRIBUTE = URL_ATTRIBUTE;
+ private final static String RSS_VERSION_ATTRIBUTE = "version";
+
+ private final static String[] RSS_REQUIRED_ATTRIBUTES = { RSS_KEY_ATTRIBUTE, RSS_URL_ATTRIBUTE };
+ private final static String[] RSS_OPTIONAL_ATTRIBUTES = { RSS_VERSION_ATTRIBUTE };
+ private final static String[] RSS_SUBNODES = { };
+
+ private String key;
+ private String url;
+ private String version;
+
+ public RSSProducerNodeBuilder() {
+ super(RSS_SUBNODES);
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, RSS_REQUIRED_ATTRIBUTES, RSS_OPTIONAL_ATTRIBUTES);
+
+ key = (String) anAttributes.get( RSS_KEY_ATTRIBUTE );
+ url = (String) anAttributes.get( RSS_URL_ATTRIBUTE );
+ version = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RSS_VERSION_ATTRIBUTE, "1.0");
+ };
+
+ public ProducerNode constructNode() {
+ return new RSSProducerNode(key, url, version);
+ };
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
+ public static class RDFAggregatorProducerNodeBuilder extends AbstractProducerNodeBuilder {
+ private final static String RDF_AGGREGATOR_KEY_ATTRIBUTE = KEY_ATTRIBUTE;
+ private final static String RDF_AGGREGATOR_SOURCE_ATTRIBUTE = "source";
+ private final static String RDF_AGGREGATOR_ORDER_ATTRIBUTE = ORDER_ATTRIBUTE;
+ private final static String RDF_AGGREGATOR_FILTER_ATTRIBUTE = "filter";
+
+ private final static String[] RDF_AGGREGATOR_REQUIRED_ATTRIBUTES = { RDF_AGGREGATOR_KEY_ATTRIBUTE, RDF_AGGREGATOR_SOURCE_ATTRIBUTE };
+ private final static String[] RDF_AGGREGATOR_OPTIONAL_ATTRIBUTES = { RDF_AGGREGATOR_ORDER_ATTRIBUTE, RDF_AGGREGATOR_FILTER_ATTRIBUTE };
+ private final static String[] RDF_AGGREGATOR_SUBNODES = { };
+
+ private String key;
+ private String source;
+ private String order;
+ private String filter;
+
+ public RDFAggregatorProducerNodeBuilder() {
+ super(RDF_AGGREGATOR_SUBNODES);
+ }
+
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributes(anAttributes, RDF_AGGREGATOR_REQUIRED_ATTRIBUTES, RDF_AGGREGATOR_OPTIONAL_ATTRIBUTES);
+
+ key = (String) anAttributes.get( RDF_AGGREGATOR_KEY_ATTRIBUTE );
+ source = (String) anAttributes.get( RDF_AGGREGATOR_SOURCE_ATTRIBUTE );
+ order = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RDF_AGGREGATOR_SOURCE_ATTRIBUTE, "");
+ filter = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RDF_AGGREGATOR_FILTER_ATTRIBUTE, "");
+ };
+
+ public ProducerNode constructNode() {
+ return new RDFAggregatorProducerNode(key, source, order, filter);
+ };
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
public static class ScriptedProducerParameterNodeBuilder implements ProducerNodeBuilder {
private String parameterName;
private String scriptedNodeName;
public static class ScriptedProducerNodeBuilder implements ProducerNodeBuilder {
private ScriptedProducerNodeDefinition definition;
private Map nodeParameterValues;
- private Map parameterValues;
+ private Map integerParameterValues;
+ private Map stringParameterValues;
public ScriptedProducerNodeBuilder(ScriptedProducerNodeDefinition aDefinition) {
definition = aDefinition;
- parameterValues = new HashMap();
- parameterValues.putAll(definition.getParameters());
+ stringParameterValues = new HashMap();
+ stringParameterValues.putAll(definition.getStringParameters());
+
+ integerParameterValues = new HashMap();
+ integerParameterValues.putAll(definition.getIntegerParameters());
nodeParameterValues = new HashMap();
}
return definition.getNodeParameters();
};
- public void setAttributes(Map anAttributes) throws ProducerConfigExc {
- ReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes());
+ public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLReader.XMLReaderExc {
+ XMLReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes());
+
+ Iterator i = anAttributes.entrySet().iterator();
+ while (i.hasNext()) {
+ Map.Entry entry = (Map.Entry) i.next();
+
+ if (definition.getIntegerParameters().keySet().contains(entry.getKey()))
+ integerParameterValues.put(entry.getKey(), entry.getValue());
+ else
+ stringParameterValues.put(entry.getKey(), entry.getValue());
+ }
};
public ProducerNode constructNode() {
- return new ScriptedProducerNode(definition, parameterValues, nodeParameterValues);
+ return new ScriptedProducerNode(definition, stringParameterValues, integerParameterValues, nodeParameterValues);
};
public static class factory implements ProducerNodeBuilderFactory {
projects / mir.git / blobdiff