/*
- * Copyright (C) 2001, 2002 The Mir-coders group
+ * Copyright (C) 2001-2006 The Mir-coders group
*
* This file is part of Mir.
*
*
* 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
*/
package mir.producer.reader;
+import java.io.File;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.io.File;
import mir.entity.adapter.EntityAdapterModel;
import mir.generator.Generator;
import mir.generator.WriterEngine;
import mir.log.LoggerWrapper;
+import mir.producer.BundleProducerNode;
import mir.producer.ConditionalProducerNode;
import mir.producer.DirCopyingProducerNode;
import mir.producer.EntityBatchingProducerNode;
import mir.producer.EntityListProducerNode;
import mir.producer.EntityModifyingProducerNode;
import mir.producer.EvaluatedAssignmentProducerNode;
+import mir.producer.ExecuteProgramProducerNode;
import mir.producer.ExpandedAssignmentProducerNode;
import mir.producer.ExternalDbProducerNode;
import mir.producer.FileDateSettingProducerNode;
import mir.producer.ProducerNode;
import mir.producer.RDFAggregatorProducerNode;
import mir.producer.RSSProducerNode;
-import mir.producer.BundleProducerNode;
-import mir.producer.ExecuteProgramProducerNode;
import mir.util.StringRoutines;
import mir.util.xml.XMLParserExc;
import mir.util.xml.XMLReaderTool;
public static void registerBuilders(ProducerNodeBuilderLibrary aBuilderLibrary,
EntityAdapterModel aModel, Generator.Library aGeneratorLibrary,
+ Generator.Interceptor anInterceptor,
WriterEngine aWriterEngine, File aSourceBasePath, File aDestinationBasePath) throws ProducerConfigExc {
aBuilderLibrary.registerBuilder("Set", EvaluatedAssignmentProducerNodeBuilder.class);
aBuilderLibrary.registerFactory("CreateEntity", new CreateEntityProducerNodeBuilder.factory(aModel));
aBuilderLibrary.registerFactory("DeleteEntity", new DeleteEntityProducerNodeBuilder.factory(aModel));
- aBuilderLibrary.registerFactory("Generate", new GeneratingProducerNodeBuilder.factory(aGeneratorLibrary, aWriterEngine));
+ aBuilderLibrary.registerFactory("Generate", new GeneratingProducerNodeBuilder.factory(aGeneratorLibrary,
+ aWriterEngine, anInterceptor));
}
public static abstract class AbstractProducerNodeBuilder implements ProducerNodeBuilder {
public void setSubNode(String aName, ProducerNode aNode) {
subNodes.put(aName, aNode);
- };
+ }
public Set getAvailableSubNodes() {
return availableSubnodes;
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new ExpandedAssignmentProducerNode(key, value);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
key = (String) anAttributes.get(ASSIGNMENT_KEY_ATTRIBUTE);
value = (String) anAttributes.get(ASSIGNMENT_VALUE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new EvaluatedAssignmentProducerNode(key, value);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
if (parts.size() > 1)
mainTablePrefix = (String) parts.get(1);
}
- };
+ }
public ProducerNode constructNode() {
if (definition!=null)
return new EntityEnumeratingProducerNode(key, model, mainTablePrefix, extraTables, definition, selection, order, limit, skip, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
- else
- return new ListEnumeratingProducerNode(key, list, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
- };
+ return new ListEnumeratingProducerNode(key, list, getSubNode(ENUMERATION_DEFAULT_SUBNODE ));
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
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;
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;
condition = (String) anAttributes.get(LOOP_CONDITION_ATTRIBUTE);
limit = XMLReaderTool.getStringAttributeWithDefault(anAttributes, LOOP_LIMIT_ATTRIBUTE, "");
- };
+ }
public ProducerNode constructNode() {
return new LoopProducerNode(condition, limit, getSubNode( LOOP_DEFAULT_SUBNODE ));
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
if (parts.size()>0) definition=(String)parts.get(0);
if (parts.size()>1) mainTablePrefix=(String)parts.get(1);
- };
+ }
public ProducerNode constructNode() {
return new EntityListProducerNode(key, model, mainTablePrefix, extraTables, definition, selection, order, limit, skip, null );
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
definition = (String) anAttributes.get(DELETEENTITY_DEFINITION_ATTRIBUTE);
selection = XMLReaderTool.getStringAttributeWithDefault(anAttributes, DELETEENTITY_SELECTION_ATTRIBUTE, "");
- };
+ }
public ProducerNode constructNode() {
return new EntityDeletingProducerNode(model, definition, selection);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
}
else
type = LoggerWrapper.INFO_MESSAGE;
- };
+ }
public ProducerNode constructNode() {
return new LoggingProducerNode(message, type);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
}
else
type = FreeQueryProducerNode.QUERY_TYPE_SET;
- };
+ }
public ProducerNode constructNode() {
return new FreeQueryProducerNode(key, query, limit, type);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
}
public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
- String typeString;
-
XMLReaderTool.checkAttributes(anAttributes, EXTDB_REQUIRED_ATTRIBUTES, EXTDB_OPTIONAL_ATTRIBUTES);
key = (String) anAttributes.get(EXTDB_KEY_ATTRIBUTE);
username = (String) anAttributes.get(EXTDB_USERNAME_ATTRIBUTE);
password = (String) anAttributes.get(EXTDB_PASSWORD_ATTRIBUTE);
query = (String) anAttributes.get(EXTDB_QUERY_ATTRIBUTE);
-
- };
+ }
public ProducerNode constructNode() {
return new ExternalDbProducerNode(key, driver, host, port, database, username, password, query, getSubNode(EXTDB_DEFAULT_SUBNODE));
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
key = (String) anAttributes.get(RESOURCEBUNDLE_KEY_ATTRIBUTE);
bundle = (String) anAttributes.get(RESOURCEBUNDLE_BUNDLE_ATTRIBUTE);
language = (String) anAttributes.get(RESOURCEBUNDLE_LANGUAGE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new BundleProducerNode(key, bundle, language);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
fileNameKey = (String) anAttributes.get(FILEDATESETTING_FILE_ATTRIBUTE);
dateKey = (String) anAttributes.get(FILEDATESETTING_DATE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new FileDateSettingProducerNode(fileNameKey, dateKey);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
XMLReaderTool.checkAttributes(anAttributes, FILEDELETING_REQUIRED_ATTRIBUTES, FILEDELETING_OPTIONAL_ATTRIBUTES);
fileNameKey = (String) anAttributes.get(FILEDELETING_FILE_ATTRIBUTE);
- };
+ }
public ProducerNode constructNode() {
return new FileDeletingProducerNode(fileNameKey);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
time = XMLReaderTool.getStringAttributeWithDefault(anAttributes, EXECUTEPROGRAM_MAXTIME_ATTRIBUTE, null);
resultvar = XMLReaderTool.getStringAttributeWithDefault(anAttributes, EXECUTEPROGRAM_RESULTVAR_ATTRIBUTE, null);
returnValueVar = XMLReaderTool.getStringAttributeWithDefault(anAttributes, EXECUTEPROGRAM_RETURNVALUE_ATTRIBUTE, null);
- };
+ }
public ProducerNode constructNode() {
return new
ExecuteProgramProducerNode(command, time, resultvar, returnValueVar);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
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 File sourceBasePath;
private String parameters;
private Generator.Library generatorLibrary;
private WriterEngine writerEngine;
+ private Generator.Interceptor interceptor;
- public GeneratingProducerNodeBuilder(Generator.Library aGeneratorLibrary, WriterEngine aWriterEngine) {
+ public GeneratingProducerNodeBuilder(Generator.Library aGeneratorLibrary, WriterEngine aWriterEngine,
+ Generator.Interceptor anInterceptor) {
super(GENERATION_SUBNODES);
writerEngine = aWriterEngine;
generatorLibrary = aGeneratorLibrary;
+ interceptor = anInterceptor;
}
public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
generator = (String) anAttributes.get(GENERATION_GENERATOR_ATTRIBUTE);
destination = (String) anAttributes.get(GENERATION_DESTINATION_ATTRIBUTE);
parameters = XMLReaderTool.getStringAttributeWithDefault(anAttributes, GENERATION_PARAMETERS_ATTRIBUTE, "" );
- };
+ }
public ProducerNode constructNode() {
- return new GeneratingProducerNode(generatorLibrary, writerEngine, generator, destination, parameters);
- };
+ return new GeneratingProducerNode(generatorLibrary, writerEngine, interceptor, generator, destination, parameters);
+ }
public static class factory implements ProducerNodeBuilderFactory {
private Generator.Library generatorLibrary;
private WriterEngine writerEngine;
+ private Generator.Interceptor interceptor;
- public factory(Generator.Library aGeneratorLibrary, WriterEngine aWriterEngine) {
+ public factory(Generator.Library aGeneratorLibrary, WriterEngine aWriterEngine, Generator.Interceptor anInterceptor) {
writerEngine = aWriterEngine;
generatorLibrary = aGeneratorLibrary;
+ interceptor = anInterceptor;
}
public ProducerNodeBuilder makeBuilder() {
- return new GeneratingProducerNodeBuilder(generatorLibrary, writerEngine);
+ return new GeneratingProducerNodeBuilder(generatorLibrary, writerEngine, interceptor);
}
}
}
skip = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_SKIP_ATTRIBUTE, "0" );
process = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_PROCESS_ATTRIBUTE, "-1" );
- extraTables = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_EXTRATABLES_ATTRIBUTE,"");
+ extraTables = XMLReaderTool.getStringAttributeWithDefault(anAttributes, BATCHER_EXTRATABLES_ATTRIBUTE, "");
- List parts = StringRoutines.splitString(definition.trim()," ");
- if (parts.size()>0) definition=(String)parts.get(0);
- if (parts.size()>1) mainTablePrefix=(String)parts.get(1);
- };
+ List parts = StringRoutines.splitString(definition.trim(), " ");
+ if (parts.size()>0) definition = (String) parts.get(0);
+ if (parts.size()>1) mainTablePrefix = (String) parts.get(1);
+ }
public ProducerNode constructNode() {
return new EntityBatchingProducerNode(
getSubNode( BATCHER_BATCH_SUBNODE ),
getSubNode( BATCHER_BATCHLIST_SUBNODE )
);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private EntityAdapterModel model;
XMLReaderTool.checkAttributes(anAttributes, IF_REQUIRED_ATTRIBUTES, IF_OPTIONAL_ATTRIBUTES);
condition = (String) anAttributes.get( IF_CONDITION_ATTRIBUTE );
- };
+ }
public ProducerNode constructNode() {
return new ConditionalProducerNode(
getSubNode( IF_TRUE_SUBNODE ),
getSubNode( IF_FALSE_SUBNODE )
);
- };
+ }
}
url = (String) anAttributes.get( RSS_URL_ATTRIBUTE );
version = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RSS_VERSION_ATTRIBUTE, "1.0");
encoding = XMLReaderTool.getStringAttributeWithDefault(anAttributes, RSS_ENCODING_ATTRIBUTE, null);
- };
+ }
public ProducerNode constructNode() {
return new RSSProducerNode(key, url, version, encoding);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
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_OPTIONAL_ATTRIBUTES = { };
private final static String[] RDF_AGGREGATOR_SUBNODES = { };
private String key;
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);
- };
+ return new RDFAggregatorProducerNode(key, source);
+ }
}
////////////////////////////////////////////////////////////////////////////////
}
public void setSubNode(String aName, ProducerNode aNode) {
- };
+ }
public Set getAvailableSubNodes() {
return new HashSet();
- };
+ }
public void setAttributes(Map anAttributes) throws ProducerConfigExc {
if (!anAttributes.isEmpty())
throw new ProducerConfigExc("No parameters allowed here");
- };
+ }
public ProducerNode constructNode() {
return new ScriptedProducerNodeDefinition.NodeParameterProducerNode(scriptedNodeName, parameterName);
- };
+ }
}
////////////////////////////////////////////////////////////////////////////////
public void setSubNode(String aName, ProducerNode aNode) {
nodeParameterValues.put(aName, aNode);
- };
+ }
public Set getAvailableSubNodes() {
return definition.getNodeParameters();
- };
+ }
public void setAttributes(Map anAttributes) throws ProducerConfigExc, XMLParserExc {
XMLReaderTool.checkAttributeSet(anAttributes.keySet(), definition.getRequiredAttributes(), definition.getOptionalAttributes());
else
stringParameterValues.put(entry.getKey(), entry.getValue());
}
- };
+ }
public ProducerNode constructNode() {
return new ScriptedProducerNode(definition, stringParameterValues, integerParameterValues, nodeParameterValues);
- };
+ }
public static class factory implements ProducerNodeBuilderFactory {
private ScriptedProducerNodeDefinition definition;
projects / mir.git / blobdiff