ServletModule.Language.ConfirmTemplate=admin/confirm.template
ServletModule.Language.ObjektTemplate=admin/language.template
ServletModule.Language.ListTemplate=admin/languagelist.template
+
+#
+# producer-related configs below
+#
+
+Producer.ExtLinkName=extlink.gif
+Producer.IntLinkName=intlink.gif
+Producer.MailLinkName=maillink.gif
+Producer.Logfile=log/producer.log
+
+Producer.Content.Template=producer/content.template
+Producer.Content.Batchsize=10
+
+
try {
ParameterExpander.setValueForKey(
aValueMap,
- key,
+ ParameterExpander.expandExpression( aValueMap, key ),
ParameterExpander.evaluateExpression( aValueMap, value ));
}
try {
ParameterExpander.setValueForKey(
aValueMap,
- key,
+ ParameterExpander.expandExpression( aValueMap, key ),
ParameterExpander.expandExpression( aValueMap, value ));
}
--- /dev/null
+/*
+ * 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 the com.oreilly.servlet library, 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;
+
+import java.util.*;
+import java.io.*;
+import mir.util.*;
+
+
+public class LoopProducerNode extends ProducerNodeDecorator {
+ private String condition;
+ private String limit;
+
+ public LoopProducerNode(
+ String aCondition,
+ String aLimit,
+ ProducerNode aSubNode) {
+ super(aSubNode);
+
+ limit = aLimit;
+ condition = aCondition;
+ }
+
+ public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ int loopNr;
+ int maxNrLoops;
+
+ try {
+ loopNr = 0;
+ maxNrLoops = ParameterExpander.evaluateIntegerExpressionWithDefault(aValueMap, limit, 1000);
+ while (ParameterExpander.evaluateBooleanExpression(aValueMap, condition) && (loopNr<maxNrLoops)) {
+ super.produce(aValueMap, aVerb, aLogger);
+ loopNr++;
+ }
+ }
+ catch (Throwable t) {
+ throw new ProducerFailure(t.getMessage(), t);
+ }
+ };
+}
\ No newline at end of file
aBuilderLibrary.registerBuilder("DeleteFile", FileDeletingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("SetFileDate", FileDateSettingProducerNodeBuilder.class);
aBuilderLibrary.registerBuilder("If", ConditionalProducerNodeBuilder.class);
+ aBuilderLibrary.registerBuilder("While", LoopProducerNodeBuilder.class);
aBuilderLibrary.registerFactory("Enumerate", new EnumeratingProducerNodeBuilder.factory(aModel));
////////////////////////////////////////////////////////////////////////////////
+ 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 {
+ ReaderTool.checkAttributes(anAttributes, LOOP_REQUIRED_ATTRIBUTES, LOOP_OPTIONAL_ATTRIBUTES);
+
+ condition = (String) anAttributes.get(LOOP_CONDITION_ATTRIBUTE);
+ limit = (String) ReaderTool.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;
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();
}
public void setAttributes(Map anAttributes) throws ProducerConfigExc {
ReaderTool.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 {
private ScriptedProducerNodeDefinition nodeDefinition;
private ProducerNode body;
private Map stringParameters;
+ private Map integerParameters;
private Map nodeParameters;
private String name;
body = null;
nodeParameters = null;
stringParameters = null;
+ integerParameters = null;
name = aName;
}
public void endElement(SectionHandler aHandler) {
if (aHandler instanceof NodeDefinitionParametersSectionHandler) {
stringParameters = ((NodeDefinitionParametersSectionHandler) aHandler).getStringParameters();
+ integerParameters = ((NodeDefinitionParametersSectionHandler) aHandler).getIntegerParameters();
nodeParameters = ((NodeDefinitionParametersSectionHandler) aHandler).getNodeParameters();
}
else if (aHandler instanceof ProducerNodeSectionHandler) {
i = stringParameters.entrySet().iterator();
while (i.hasNext()) {
Map.Entry entry = (Map.Entry) i.next();
- nodeDefinition.addParameter((String) entry.getKey(), (String) entry.getValue());
+ nodeDefinition.addStringParameter((String) entry.getKey(), (String) entry.getValue());
+ }
+
+ i = integerParameters.entrySet().iterator();
+ while (i.hasNext()) {
+ Map.Entry entry = (Map.Entry) i.next();
+ nodeDefinition.addIntegerParameter((String) entry.getKey(), (String) entry.getValue());
}
}
public class NodeDefinitionParametersSectionHandler extends SectionHandler {
private Map nodeParameters;
private Map stringParameters;
+ private Map integerParameters;
public NodeDefinitionParametersSectionHandler() {
nodeParameters = new HashMap();
stringParameters = new HashMap();
+ integerParameters = new HashMap();
}
public SectionHandler startElement(String aTag, Map anAttributes) throws ProducerConfigExc {
return new EmptySectionHandler();
}
- else if (aTag.equals("string")) {
+ else if (aTag.equals("string") || aTag.equals("integer")) {
ReaderTool.checkAttributes(anAttributes, NODE_DEFINITION_PARAMETER_REQUIRED_ATTRIBUTES, NODE_DEFINITION_PARAMETER_OPTIONAL_ATTRIBUTES);
parameterName = (String) anAttributes.get( NODE_DEFINITION_PARAMETER_NAME_ATTRIBUTE );
- if (stringParameters.containsKey(parameterName))
+ if (stringParameters.containsKey(parameterName) || integerParameters.containsKey(parameterName))
throw new ProducerConfigExc("Duplicate parameter name: '" + parameterName + "'");
ReaderTool.checkValidIdentifier( parameterName );
defaultValue = (String) anAttributes.get( NODE_DEFINITION_PARAMETER_DEFAULTVALUE_ATTRIBUTE );
- stringParameters.put(parameterName, defaultValue);
+ if (aTag.equals("string"))
+ stringParameters.put(parameterName, defaultValue);
+ else
+ integerParameters.put(parameterName, defaultValue);
return new EmptySectionHandler();
}
- else throw new ProducerConfigExc("Only 'string' and 'node' tags allowed here, '" + aTag + "' encountered.");
+ else throw new ProducerConfigExc("Only 'string', 'integer' and 'node' tags allowed here, '" + aTag + "' encountered.");
}
public Map getStringParameters() {
return stringParameters;
}
+
+ public Map getIntegerParameters() {
+ return integerParameters;
+ }
}
}
public class ScriptedProducerNode implements ProducerNode {
private ScriptedProducerNodeDefinition definition;
- private Map parameterValues;
+ private Map integerParameterValues;
+ private Map stringParameterValues;
private Map nodeParameterValues;
- public ScriptedProducerNode(ScriptedProducerNodeDefinition aDefinition, Map aParameterValues, Map aNodeParameterValues) {
+ public ScriptedProducerNode(ScriptedProducerNodeDefinition aDefinition, Map aStringParameterValues, Map anIntegerParameterValues, Map aNodeParameterValues) {
definition = aDefinition;
- parameterValues = new HashMap();
- parameterValues.putAll(aParameterValues);
+ stringParameterValues = new HashMap();
+ stringParameterValues.putAll(aStringParameterValues);
+ integerParameterValues = new HashMap();
+ integerParameterValues.putAll(anIntegerParameterValues);
nodeParameterValues = new HashMap();
nodeParameterValues.putAll(aNodeParameterValues);
}
public void produce(Map aValues, String aVerb, PrintWriter aLogger) throws ProducerFailure, ProducerExc {
try {
- Map oldValues = ScriptedProducerNodeTool.saveMapValues(aValues, definition.getParameters().keySet());
+ Map oldValues = new HashMap();
+ ScriptedProducerNodeTool.saveMapValues(oldValues, aValues, definition.getStringParameters().keySet());
+ ScriptedProducerNodeTool.saveMapValues(oldValues, aValues, definition.getIntegerParameters().keySet());
try {
- Iterator i = parameterValues.entrySet().iterator();
+ Iterator i = stringParameterValues.entrySet().iterator();
while (i.hasNext()) {
Map.Entry entry = (Map.Entry) i.next();
}
}
+ i = integerParameterValues.entrySet().iterator();
+
+ while (i.hasNext()) {
+ Map.Entry entry = (Map.Entry) i.next();
+
+ if (entry.getValue() instanceof String) {
+ aValues.put(entry.getKey(), ParameterExpander.evaluateExpression(aValues, (String) entry.getValue()));
+ }
+ }
+
ScriptedProducerNodeTool.pushNodeParameterValues(aValues, definition.getName(), nodeParameterValues);
try {
definition.getBody().produce(aValues, aVerb, aLogger);
}
}
finally {
- ScriptedProducerNodeTool.restoreMapValues(aValues, definition.getParameters().keySet(), oldValues);
+ ScriptedProducerNodeTool.restoreMapValues(aValues, definition.getIntegerParameters().keySet(), oldValues);
+ ScriptedProducerNodeTool.restoreMapValues(aValues, definition.getStringParameters().keySet(), oldValues);
}
}
catch (Exception e) {
import mir.producer.*;
public class ScriptedProducerNodeDefinition {
- private Map parameters; // name -> default value
+ private Map integerParameters; // name -> default value
+ private Map stringParameters; // name -> default value
private Set nodeParameters;
private ProducerNode body;
private String name;
public ScriptedProducerNodeDefinition(String aName) {
name = aName;
- parameters = new HashMap();
+ integerParameters = new HashMap();
+ stringParameters = new HashMap();
nodeParameters = new HashSet();
body = new CompositeProducerNode();
}
- public void addParameter(String aName, String aDefaultValue) {
- parameters.put(aName, aDefaultValue);
+ public void addStringParameter(String aName, String aDefaultValue) {
+ stringParameters.put(aName, aDefaultValue);
+ }
+
+ public void addIntegerParameter(String aName, String aDefaultValue) {
+ integerParameters.put(aName, aDefaultValue);
}
public void addNodeParameter(String aName) {
body = aBody;
}
- protected Map getParameters() {
- return parameters;
+ protected Map getStringParameters() {
+ return stringParameters;
+ }
+
+ protected Map getIntegerParameters() {
+ return integerParameters;
}
protected Set getNodeParameters() {
public Set getAttributesSelection(boolean aRequired) {
Set result = new HashSet();
- Iterator i = parameters.entrySet().iterator();
+ Iterator i = stringParameters.entrySet().iterator();
+
+ while (i.hasNext()) {
+ Map.Entry entry = (Map.Entry) i.next();
+
+ if ((entry.getValue() == null) == aRequired ) {
+ result.add(entry.getKey());
+ }
+ }
+
+ i = integerParameters.entrySet().iterator();
while (i.hasNext()) {
Map.Entry entry = (Map.Entry) i.next();
runtimeStack.pop();
}
- public static Map saveMapValues(Map aMap, Set aKeys) {
- Map result = new HashMap();
+ public static void saveMapValues(Map aDestination, Map aSource, Set aKeys) {
Iterator i = aKeys.iterator();
while (i.hasNext()) {
Object key = i.next();
- if (aMap.containsKey(key))
- result.put(key, aMap.get(key));
+ if (aSource.containsKey(key))
+ aDestination.put(key, aSource.get(key));
}
-
- return result;
}
public static void restoreMapValues(Map aMap, Set aKeys, Map aSavedValues) {
--- /dev/null
+/*
+ * 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 the com.oreilly.servlet library, 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.util;
+
+import java.util.*;
+import java.net.*;
+
+//import mir.misc.*;
+import mir.generator.*;
+
+public class GeneratorListFunctions {
+ private GeneratorListFunctions() {}
+
+ public static class subListFunction implements Generator.GeneratorFunction {
+ public Object perform(List aParameters) throws GeneratorExc, GeneratorFailure {
+ try {
+ int skip;
+ int maxSize;
+
+ if (aParameters.size()>3 || aParameters.size()<2)
+ throw new GeneratorExc("iteratorSubsetFunction: 2 or 3 parameters expected");
+ if (aParameters.get(0)==null)
+ return "";
+
+ if (!(aParameters.get(0) instanceof RewindableIterator) && !(aParameters.get(0) instanceof List))
+ throw new GeneratorExc("iteratorSubsetFunction: first parameter must be a RewindableIterator (not a "+aParameters.get(0).getClass().getName()+")");
+
+ skip = StringRoutines.interpretAsInteger(aParameters.get(1));
+ if (aParameters.size()>=2)
+ maxSize = StringRoutines.interpretAsInteger(aParameters.get(2));
+ else
+ maxSize = -1;
+
+
+ if ((aParameters.get(0) instanceof RewindableIterator))
+ return new SubsetIterator((RewindableIterator) aParameters.get(0), skip, maxSize);
+ else {
+ List list = (List) aParameters.get(0);
+
+ if (skip>=list.size())
+ return new Vector();
+ if (maxSize<0 || (skip+maxSize)>=list.size())
+ return list.subList(skip, list.size());
+ else
+ return list.subList(skip, skip+maxSize);
+ }
+ }
+ catch (GeneratorExc e) {
+ throw e;
+ }
+ catch (GeneratorFailure e) {
+ throw e;
+ }
+ catch (Throwable e) {
+ throw new GeneratorFailure(e);
+ }
+ };
+ }
+}
private GeneratorStringFunctions() {}
- public static int interpretAsInteger(Object aValue) throws GeneratorExc {
- if (aValue instanceof Integer)
- return ((Integer) aValue).intValue();
-
- if (aValue instanceof String)
- try {
- return Integer.parseInt((String) aValue);
- }
- catch (Throwable t) {
- throw new GeneratorExc("Integer expected, "+aValue+" found");
- }
-
- throw new GeneratorExc("Integer expected, "+aValue+" found");
- }
-
public static String interpretAsString(Object aValue) throws GeneratorExc {
if (aValue instanceof String)
return (String) aValue;
if (aParameters.size()==3) {
return interpretAsString(aParameters.get(0)).substring(
- interpretAsInteger(aParameters.get(1)),
- interpretAsInteger(aParameters.get(2)));
+ StringRoutines.interpretAsInteger(aParameters.get(1)),
+ StringRoutines.interpretAsInteger(aParameters.get(2)));
}
else {
return interpretAsString(aParameters.get(0)).substring(
- interpretAsInteger(aParameters.get(1)));
+ StringRoutines.interpretAsInteger(aParameters.get(1)));
}
}
catch (GeneratorExc e) {
List parameters;
do {
- token = scanner.scan();
+ token = scanner.peek();
+
if (token instanceof LeftSquareBraceToken) {
+ scanner.scan();
qualifier = parseUntil(MAX_OPERATOR_LEVEL);
token = scanner.scan();
if (!(token instanceof RightSquareBraceToken))
}
}
else if (token instanceof IdentifierToken) {
+ scanner.scan();
qualifier = ((IdentifierToken) token).getName();
if (currentValue instanceof Map) {
value = parseUntil(unaryOperatorLevel(token));
value = expandOperatorExpression(token, value);
}
- else if (token instanceof IdentifierToken) {
+ else if (token instanceof IdentifierToken || token instanceof LeftSquareBraceToken) {
value = parseVariable();
}
else if (token instanceof LiteralToken) {
public SimpleParser(String aData) {
data=aData;
position=0;
-
- System.out.println("Will parse: "+aData);
}
public boolean parses(RE aRegularExpression) throws SimpleParserExc {
public String parse(String anExpression, String aMessage) throws SimpleParserExc, SimpleParserFailure {
try {
- System.out.println("Expression: "+anExpression);
-
return parse(new RE(anExpression), aMessage);
}
catch (SimpleParserExc e) {
return result;
}
+ public static int interpretAsInteger(Object aValue) throws Exception {
+ if (aValue instanceof Integer)
+ return ((Integer) aValue).intValue();
+
+ if (aValue instanceof String)
+ try {
+ return Integer.parseInt((String) aValue);
+ }
+ catch (Throwable t) {
+ throw new Exception("Integer expected, "+aValue+" found");
+ }
+
+ throw new Exception("Integer expected, "+aValue+" found");
+ }
+
public static String performRegularExpressionReplacement(String aSource,
String aSearchExpression, String aReplacement) throws Exception {
--- /dev/null
+/*
+ * 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 the com.oreilly.servlet library, 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.util;
+
+import java.util.*;
+
+import java.util.*;
+import mir.storage.*;
+import mir.util.*;
+import mir.entity.*;
+
+public class SubsetIterator implements RewindableIterator {
+ private RewindableIterator master;
+ private List cachedItems;
+ private int position;
+ private int skip;
+ private int maxLength;
+
+ public SubsetIterator(RewindableIterator anIterator, int aSkip, int aMaxLength) {
+ master = anIterator;
+ position = 0;
+ skip = aSkip;
+ maxLength = aMaxLength;
+ }
+
+ public boolean hasNext() {
+ while (position<skip && master.hasNext()) {
+ getNext();
+ }
+
+ return ((maxLength==-1) || (position<skip+maxLength)) && master.hasNext();
+ }
+
+ public Object getNext() {
+ position++;
+ return master.next();
+ }
+
+ public Object next() {
+ if (hasNext())
+ return getNext();
+ else
+ throw new NoSuchElementException();
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ public void rewind() {
+ position=0;
+ master.rewind();
+ };
+}
\ No newline at end of file
utilityMap.put("encodeHTML", new GeneratorHTMLFunctions.encodeHTMLGeneratorFunction());
utilityMap.put("encodeURI", new GeneratorHTMLFunctions.encodeURIGeneratorFunction());
utilityMap.put("subString", new GeneratorStringFunctions.subStringFunction());
+ utilityMap.put("subList", new GeneratorListFunctions.subListFunction());
+
aValueSet.put("config", configMap);
aValueSet.put("utility", utilityMap);
producerFactories = newProducers;
fileMonitor = newFileMonitor;
+ logger.printError("MirBasicProducerLocalizer.factories(): successfully setup factories");
}
catch (Throwable t) {
logger.printError("MirBasicProducerLocalizer.factories(): Unable to setup factories: "+t.getMessage());
projects / mir.git / commitdiff