/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/**
* Modified Logs:
*
* 07-16-2007
* Remove the code that does duplicate operations when adding Collection Reader
* and CasProcessors.
* Note: Look at "addCpeDescription" by searching for testIt flag
*
*/
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.application.metadata.impl;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.StringWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import org.apache.uima.ResourceSpecifierFactory;
import org.apache.uima.UIMAFramework;
import org.apache.uima.UIMA_IllegalStateException;
import org.apache.uima.aae.deployment.AsyncPrimitiveErrorConfiguration;
import org.apache.uima.analysis_engine.AnalysisEngineDescription;
import org.apache.uima.analysis_engine.TaeDescription;
import org.apache.uima.analysis_engine.metadata.AnalysisEngineMetaData;
import org.apache.uima.application.metadata.IRuntimeContext;
import org.apache.uima.application.metadata.IStringSubstitution;
import org.apache.uima.application.metadata.UimaApplication;
import org.apache.uima.application.metadata.UimaCasProcessor;
import org.apache.uima.application.util.UimaXmlParsingUtil;
import org.apache.uima.collection.CasConsumerDescription;
import org.apache.uima.collection.CasInitializerDescription;
import org.apache.uima.collection.CollectionReaderDescription;
import org.apache.uima.collection.impl.metadata.cpe.CpeCasProcessorsImpl;
import org.apache.uima.collection.impl.metadata.cpe.CpeDescriptionImpl;
import org.apache.uima.collection.impl.metadata.cpe.CpeDescriptorFactory;
import org.apache.uima.collection.metadata.CasProcessorConfigurationParameterSettings;
import org.apache.uima.collection.metadata.CasProcessorErrorHandling;
import org.apache.uima.collection.metadata.CasProcessorErrorRateThreshold;
import org.apache.uima.collection.metadata.CasProcessorMaxRestarts;
import org.apache.uima.collection.metadata.CpeCasProcessor;
import org.apache.uima.collection.metadata.CpeCheckpoint;
import org.apache.uima.collection.metadata.CpeCollectionReader;
import org.apache.uima.collection.metadata.CpeCollectionReaderCasInitializer;
import org.apache.uima.collection.metadata.CpeComponentDescriptor;
import org.apache.uima.collection.metadata.CpeConfiguration;
import org.apache.uima.collection.metadata.CpeDescription;
import org.apache.uima.collection.metadata.CpeDescriptorException;
import org.apache.uima.cpe.model.ConfigParameterModel;
import org.apache.uima.cpe.model.ConfigParametersModel;
import org.apache.uima.cpe.model.CpeCasProcessorsSettings;
import org.apache.uima.cpe.model.DefaultCasProcessorSettings;
import org.apache.uima.cpe.model.UimaCasInitializer;
import org.apache.uima.cpe.model.UimaCollectionReader;
import org.apache.uima.resource.CustomResourceSpecifier;
import org.apache.uima.resource.ResourceConfigurationException;
import org.apache.uima.resource.ResourceInitializationException;
import org.apache.uima.resource.ResourceManager;
import org.apache.uima.resource.ResourceSpecifier;
import org.apache.uima.resource.URISpecifier;
import org.apache.uima.resource.metadata.ProcessingResourceMetaData;
import org.apache.uima.resource.metadata.TypePriorities;
import org.apache.uima.resource.metadata.TypeSystemDescription;
import org.apache.uima.resource.metadata.impl.MetaDataObject_impl;
import org.apache.uima.resource.metadata.impl.PropertyXmlInfo;
import org.apache.uima.resource.metadata.impl.XmlizationInfo;
import org.apache.uima.tools.debug.util.Trace;
import org.apache.uima.util.CasCreationUtils;
import org.apache.uima.util.InvalidXMLException;
import org.apache.uima.util.XMLInputSource;
import org.apache.uima.util.XMLParser;
import org.apache.uima.util.XMLSerializer;
import org.apache.uima.util.XMLizable;
import org.eclipse.core.variables.VariablesPlugin;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
public class UimaApplication_Impl extends MetaDataObject_impl implements UimaApplication
{
private static final long serialVersionUID = -8677679822323086638L;
private static XMLParser uimaXMLParser;
private static UimaApplication instance = null;
protected IRuntimeContext runtimeContext = new RuntimeContext ();
// CPE Configuration Settings
private CpeConfiguration cpeConfiguration = null;
// Default Settings for EACH Cas Processor
private DefaultCasProcessorSettings defaultCasProcessorSettings = null;
// Default values of CasProcessorErrorHandling as defined by CPE
// if no explicite settings in CPE Xml descriptor
// This variable is used to compare with the value returned by
// CasProcessor.getErrorHandling() which is NOT GOOD enough to identify if
// ErrorHandling IS SET or NOT in CPE Xml descriptor
private CasProcessorErrorHandling cpeDefaultErrorHandling = null;
// Settings for CpeCasProcessors
private CpeCasProcessorsSettings cpeCasProcessorsSettings = new CpeCasProcessorsSettings();
// List of UimaCollectionReader
private List uimaCollectionReaders = new ArrayList();
private List uimaCasInitializers = new ArrayList();
// List of UimaCasProcessors
private List uimaCasProcessors = new ArrayList();
// private CpeDescriptorModel mCpeDescriptorModel = null;
// private UimaCasProcessor[] mUimaCasProcessors;
private String cpeHref = null;
static boolean isInitialized_UimaApplicationFramework = false;
/*************************************************************************/
static private IStringSubstitution stringSubstitutionManager = null;
static public IStringSubstitution getStringSubstitutionManager () {
return stringSubstitutionManager;
}
static public void setStringSubstitutionManager (IStringSubstitution manager) {
stringSubstitutionManager = manager;
}
static public String resolveUimaXmlDescriptor (String xmlDescriptor)
{
if (stringSubstitutionManager != null) {
// May return null
return stringSubstitutionManager.resolveUimaXmlDescriptor(xmlDescriptor);
} else {
// Trace.trace("NULL");
return xmlDescriptor;
}
}
static public String generateVariableExpression (String variableName, String arg)
{
return VariablesPlugin.getDefault().getStringVariableManager()
.generateVariableExpression(variableName, arg);
}
protected String toWorkspaceRelativePath (String xml)
{
String resolvedFileName = resolveUimaXmlDescriptor(xml);
File f = new File(resolvedFileName);
if ( !f.isAbsolute() ) {
// Relative path
if ( ! f.exists() ) {
// Can NOT find file.
// Try to find it within CURRENT DIRECTORY
f = new File (currentDir, resolvedFileName);
if ( ! f.exists() ) {
Trace.err("*** ERROR: Cannot find file: " + resolvedFileName);
} else {
resolvedFileName = f.getAbsolutePath();
}
}
// Trace.trace("+++ New xml:" + resolvedFileName);
}
resolvedFileName = generateVariableExpression("workspace_loc", resolvedFileName); //$NON-NLS-1$
// File.
return resolvedFileName;
}
/*************************************************************************/
/**
* Initialize UIMA XMLParser with new extension tags
*
*/
static public void initUimaApplicationFramework ()
{
if (isInitialized_UimaApplicationFramework) return;
isInitialized_UimaApplicationFramework = true;
uimaXMLParser = org.apache.uima.UIMAFramework.getXMLParser();
try {
uimaXMLParser.addMapping("uimaApplication",
"org.apache.uima.application.metadata.impl.UimaApplication_Impl");
uimaXMLParser.addMapping(TAG_COLLECTION_READER,
"org.apache.uima.cpe.model.UimaCollectionReader");
uimaXMLParser.addMapping(TAG_CAS_PROCESSOR,
"org.apache.uima.application.metadata.impl.UimaCasProcessor_impl");
uimaXMLParser.addMapping(TAG_DEPLOYMENT_OVERRIDES,
"org.apache.uima.application.metadata.impl.DeploymentOverrides_impl");
uimaXMLParser.addMapping(TAG_CONFIG_PARAM_OVERRIDES,
"org.apache.uima.application.metadata.impl.ConfigParamOverrides_impl");
uimaXMLParser.addMapping(TAG_CONFIG_PARAM_OVERRIDE_SET,
"org.apache.uima.application.metadata.impl.OverrideSet_impl");
//
// For UIMA-ee Parsing
//
uimaXMLParser.addMapping("analysisEngineDeploymentDescription",
"org.apache.uima.aae.deployment.impl.AEDeploymentDescription_Impl");
uimaXMLParser.addMapping("service",
"org.apache.uima.aae.deployment.impl.AEService_Impl");
uimaXMLParser.addMapping("analysisEngine",
"org.apache.uima.aae.deployment.impl.AEDeploymentMetaData_Impl");
uimaXMLParser.addMapping("remoteAnalysisEngine",
"org.apache.uima.aae.deployment.impl.RemoteAEDeploymentMetaData_Impl");
uimaXMLParser.addMapping("asyncAggregateErrorConfiguration",
"org.apache.uima.aae.deployment.impl.AsyncAggregateErrorConfiguration_Impl");
uimaXMLParser.addMapping("asyncPrimitiveErrorConfiguration",
"org.apache.uima.aae.deployment.impl.AsyncPrimitiveErrorConfiguration_Impl");
// parse("c:/uima/Test/testApp.xml");
//
// For object creation
//
ResourceSpecifierFactory factory = UIMAFramework.getResourceSpecifierFactory();
factory.addMapping("org.apache.uima.aae.deployment.AEDeploymentDescription",
"org.apache.uima.aae.deployment.impl.AEDeploymentDescription_Impl");
factory.addMapping("org.apache.uima.aae.deployment.AEDeploymentMetaData",
"org.apache.uima.aae.deployment.impl.AEDeploymentMetaData_Impl");
factory.addMapping("org.apache.uima.aae.deployment.RemoteAEDeploymentMetaData",
"org.apache.uima.aae.deployment.impl.RemoteAEDeploymentMetaData_Impl");
factory.addMapping("org.apache.uima.aae.deployment.AsyncAggregateErrorConfiguration",
"org.apache.uima.aae.deployment.impl.AsyncAggregateErrorConfiguration_Impl");
factory.addMapping("org.apache.uima.aae.deployment.AsyncPrimitiveErrorConfiguration",
"org.apache.uima.aae.deployment.impl.AsyncPrimitiveErrorConfiguration_Impl");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} // initUimaApplicationFramework
/*************************************************************************/
// Note: cannot be "protected" since it is used by XMLParser
public UimaApplication_Impl ()
{
super();
instance = this;
// runtimeContext = new RuntimeContext ();
defaultCasProcessorSettings = new DefaultCasProcessorSettings();
cpeDefaultErrorHandling = getCpeDefaultErrorHandling ();
cpeCasProcessorsSettings = new CpeCasProcessorsSettings();
// printErrorHandling(cpeDefaultErrorHandling);
}
/*************************************************************************/
// Duplicate in UimaXmlParsingUtil
public static XMLizable parseUimaXmlDescriptor (String xmlDescriptorFileName)
{
XMLizable descriptionObject = null;
File descFile = new File(xmlDescriptorFileName);;
boolean validArgs = descFile.exists() && !descFile.isDirectory();
if (!validArgs) {
Trace.err("Cannot find: " +xmlDescriptorFileName);
return null;
}
try {
// Redirect UIMA log messages to file
UIMAFramework.getLogger().setOutputStream(
new PrintStream(new FileOutputStream("uima.log")));
// turn off xi:include and environment variable expansion
// XMLParser.ParsingOptions parsingOptions = new XMLParser.ParsingOptions(
// false, false);
// Get Resource Specifier from XML file
XMLInputSource in;
in = new XMLInputSource(descFile);
// descriptionObject = UIMAFramework.getXMLParser().parse(in, parsingOptions);
descriptionObject = UIMAFramework.getXMLParser().parse(in);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
} catch (InvalidXMLException e) {
Trace.err("xmlDescriptorFileName: " + xmlDescriptorFileName);
e.printStackTrace();
return null;
} catch (UIMA_IllegalStateException e) {
Trace.err("xmlDescriptorFileName: " + xmlDescriptorFileName);
// e.printStackTrace();
return null;
}
return descriptionObject;
} // parseUimaXmlDescriptor
static public TypeSystemDescription getTypeSystemDescription (ResourceSpecifier specifier)
{
TypeSystemDescription tsDescription = null;
try {
if (specifier instanceof TaeDescription) {
TaeDescription tae = (TaeDescription) specifier;
if ( tae.isPrimitive() ) {
tsDescription = tae.getAnalysisEngineMetaData().getTypeSystem();
} else {
tsDescription = CasCreationUtils.mergeDelegateAnalysisEngineTypeSystems(tae);
}
} else if (specifier instanceof CasConsumerDescription) {
CasConsumerDescription ccDescr = (CasConsumerDescription) specifier;
tsDescription = ccDescr.getCasConsumerMetaData().getTypeSystem();
} else if (specifier instanceof CollectionReaderDescription) {
CollectionReaderDescription crDescr = (CollectionReaderDescription) specifier;
tsDescription = crDescr.getCollectionReaderMetaData().getTypeSystem();
}
} catch (ResourceInitializationException e) {
e.printStackTrace();
}
return tsDescription;
} // getTypeSystemDescription
/*************************************************************************/
public TypeSystemDescription getTypeSystemDescription ()
{
TypeSystemDescription mergedTypeSystemDescription = null;
List typeSystemList = new ArrayList();
String resolvedXmlFile = null;
// try {
//
// Add Collection Reader
String aCollectionReaderPath = "";
List list = getUimaCollectionReaders();
// CpeCollectionReader cr = null;
if (list != null && list.size() > 0) {
aCollectionReaderPath = ((UimaCollectionReader)list.get(0)).getXmlDescriptor();
resolvedXmlFile = resolveUimaXmlDescriptor(aCollectionReaderPath);
CollectionReaderDescription crDescr = (CollectionReaderDescription) parseUimaXmlDescriptor (resolvedXmlFile);
typeSystemList.add(crDescr.getCollectionReaderMetaData().getTypeSystem());
}
// Add Cas Processors (AE, Cas Consumer)
list = getUimaCasProcessors();
for (int i=0; i<list.size(); ++i) {
UimaCasProcessor u = (UimaCasProcessor) list.get(i);
resolvedXmlFile = resolveUimaXmlDescriptor(u.getXmlDescriptor());
ResourceSpecifier specifier = null;
try {
specifier = UIMAFramework.getXMLParser()
.parseResourceSpecifier(new XMLInputSource(resolvedXmlFile));
} catch (InvalidXMLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (specifier == null) {
continue;
}
typeSystemList.add(getTypeSystemDescription(specifier));
}
// Create Merged Type System
try {
mergedTypeSystemDescription = CasCreationUtils.mergeTypeSystems(typeSystemList);
} catch (ResourceInitializationException e) {
e.printStackTrace();
return null;
}
// Set Name and Description
mergedTypeSystemDescription.setName("Merged Type System for ???");
String descr = "Merge TSs of: ";
for (int i=0; i<typeSystemList.size(); ++i) {
if (i > 0) {
descr += ", ";
}
descr += ((TypeSystemDescription) typeSystemList.get(i)).getName();
}
mergedTypeSystemDescription.setDescription(descr);
return mergedTypeSystemDescription;
}
public static String toXML (TypeSystemDescription typeSystemDescription)
{
String tsDescString = null;
StringWriter sw = new StringWriter();
try {
typeSystemDescription.toXML(sw);
tsDescString = sw.toString();
sw.close();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return tsDescString;
}
/*************************************************************************/
public void printErrorHandling (CasProcessorErrorHandling errorHandling)
{
Trace.trace("ErrorRateThreshold().getAction: " + errorHandling.getErrorRateThreshold().getAction());
Trace.trace("ErrorRateThreshold().getMaxErrorCount: " + errorHandling.getErrorRateThreshold().getMaxErrorCount());
Trace.trace("ErrorRateThreshold().getMaxErrorSampleSize: " + errorHandling.getErrorRateThreshold().getMaxErrorSampleSize());
}
static public UimaApplication getInstance () {
return instance;
}
public void removeAll ()
{
cpeHref = null;
cpeConfiguration = null;
defaultCasProcessorSettings.removeAll();
uimaCollectionReaders.clear();
uimaCasProcessors.clear();
}
// get default values of CpeCheckpoint as defined by CPE
// if no explicite settings in CPE Xml descriptor
static public CpeCheckpoint getCpeDefaultCheckpoint ()
{
// CPE BUG!!! Need to call CpeDescriptorFactory.produceDescriptor();
// CpeDescription cpeDesc = CpeDescriptorFactory.produceDescriptor();
CpeCheckpoint c = CpeDescriptorFactory.produceCpeCheckpoint();
// CPE BUG!!! Need to set some value before calling getFrequency()
c.setFrequency(600000, true);
return c;
}
// get default values of CasProcessorErrorHandling as defined by CPE
// if no explicite settings in CPE Xml descriptor
static public CasProcessorErrorHandling getCpeDefaultErrorHandling ()
{
// CPE BUG!!! Need to call CpeDescriptorFactory.produceDescriptor();
// CpeDescription cpeDesc = CpeDescriptorFactory.produceDescriptor();
CpeCasProcessor casProc = CpeDescriptorFactory.produceCasProcessor("dummy name");
return casProc.getErrorHandling();
}
static public void setCasProcessorErrorHandling(CpeCasProcessor casProc,
CasProcessorErrorHandling errorHandling)
{
if (errorHandling == null) {
return;
}
casProc.setActionOnMaxError(errorHandling.getErrorRateThreshold().getAction());
casProc.setMaxErrorCount(errorHandling.getErrorRateThreshold().getMaxErrorCount());
casProc.setMaxErrorSampleSize(errorHandling.getErrorRateThreshold().getMaxErrorSampleSize());
casProc.setMaxRestartCount(errorHandling.getMaxConsecutiveRestarts().getRestartCount());
casProc.setActionOnMaxRestart(errorHandling.getMaxConsecutiveRestarts().getAction());
casProc.setTimeout(errorHandling.getTimeout().get());
}
// static public UimaApplication createUimaApplication ()
// {
// initUimaApplicationFramework ();
// instance = new UimaApplication_Impl();
//
// return instance;
// }
static public UimaApplication createUimaApplication (ResourceManager rm)
{
initUimaApplicationFramework ();
instance = new UimaApplication_Impl();
instance.setResourceManager(rm);
return instance;
}
/**
* Create UimaApplication from Uima Application XML Descriptor
*
*/
static public UimaApplication createUimaApplication (String appXmlDescriptorFile)
{
initUimaApplicationFramework ();
UimaApplication_Impl u = null;
try {
u = (UimaApplication_Impl) uimaXMLParser.parse(new XMLInputSource(appXmlDescriptorFile));
String cpeXml = u.getCpeDescriptor();
if (cpeXml != null && cpeXml.trim().length()>0) {
u.cpeHref = cpeXml;
// Trace.trace("cpeXml: " + cpeXml);
// u.mCpeDescriptorModel = CpeDescriptorModel.createInstance (cpeXml);
// u.mCpeDescriptorModel.setUimaApplication (u);
u.initUimaCasProcessors(); // Right now, DO NOTHING
}
} catch (InvalidXMLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
instance = u;
return (UimaApplication) u;
}
/**
* Create UimaApplication from UimaApplication Object
*
*/
static public void populateCpeDescriptor (UimaApplication uimaApp)
throws InvalidXMLException, ResourceInitializationException, CpeDescriptorException
{
UimaApplication_Impl u = (UimaApplication_Impl) uimaApp;
String cpeXml = resolveUimaXmlDescriptor(uimaApp.getCpeDescriptor());
if (cpeXml != null && cpeXml.trim().length()>0) {
u.cpeHref = cpeXml;
CpeDescription cpeDescription = null;
try {
cpeDescription = UIMAFramework.getXMLParser().parseCpeDescription(new XMLInputSource(new File(cpeXml)));
} catch (InvalidXMLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
u.addXMLizable(cpeXml, cpeDescription);
// Trace.trace("cpeXml: " + cpeXml);
// u.mCpeDescriptorModel = CpeDescriptorModel.createInstance (cpeXml);
// u.mCpeDescriptorModel.setUimaApplication (uimaApp);
// u.initUimaCasProcessors();
}
instance = u;
}
static public UimaApplication createUimaApplication (String cpeXml, CpeDescription cpeDescription)
{
UimaApplication_Impl uimaApp = new UimaApplication_Impl();
uimaApp.cpeHref = cpeXml;
// Trace.trace("cpeXml: " + cpeXml);
// uimaApp.createUimaCasProcessors();
instance = uimaApp;
return (UimaApplication) uimaApp;
}
/**
* Create UimaApplication from CpeDescription
*
* @param cpeDescription
* @return UimaApplication
* @throws IOException
*/
// static public UimaApplication createUimaApplication (CpeDescription cpeDescription)
// {
// UimaApplication_Impl uimaApp = new UimaApplication_Impl();
//
// // uimaApp.cpeHref = cpeXml;
// // Trace.trace("cpeXml: " + cpeXml);
//// uimaApp.mCpeDescriptorModel = CpeDescriptorModel.createInstance (cpeXml, cpeDescription);
//// uimaApp.mCpeDescriptorModel.setUimaApplication (uimaApp);
// // uimaApp.createUimaCasProcessors();
// instance = uimaApp;
// return (UimaApplication) uimaApp;
// }
static public UimaApplication createUimaApplication (UimaApplication uimaApp, String xmlFile,
ResourceManager rm)
throws InvalidXMLException, ResourceInitializationException, CpeDescriptorException, IOException
{
String resolvedXmlFile = resolveUimaXmlDescriptor(xmlFile);
// try {
// resolvedXmlFile = VariablesPlugin.getDefault().getStringVariableManager()
// .performStringSubstitution(xmlFile);
// } catch (CoreException e1) {
// // TODO Auto-generated catch block
// e1.printStackTrace();
// }
// XMLizable xmlLizable = UIMATypeSystemUtils.parseUimaXmlDescriptor (xmlFile);
Object xmlLizable = null;
InvalidXMLException invalidXMLException = null;
try {
xmlLizable = UimaXmlParsingUtil.parseUimaXmlDescriptor (resolvedXmlFile);
} catch (InvalidXMLException e) {
invalidXMLException = e;
e.printStackTrace();
}
if (xmlLizable == null) {
// Check for CPE descriptor
// Trace.trace("XMLizable == NULL for: " + resolvedXmlFile);
try {
xmlLizable = UIMAFramework.getXMLParser().parseCpeDescription(new XMLInputSource(new File(resolvedXmlFile)));
} catch (InvalidXMLException e) {
invalidXMLException = e;
e.printStackTrace();
}
if (xmlLizable == null) {
if (invalidXMLException != null) {
throw invalidXMLException;
}
return null;
}
}
if (xmlLizable instanceof UimaApplication) {
uimaApp.setResourceManager(rm);
UimaApplication_Impl.populateCpeDescriptor((UimaApplication)xmlLizable);
} else if (xmlLizable instanceof CpeDescription) {
// Trace.trace("*** XMLizable: CpeDescription ***");
if (uimaApp == null) {
uimaApp = UimaApplication_Impl.createUimaApplication (rm);
}
uimaApp.addXMLizable(xmlFile, (CpeDescription)xmlLizable);
} else if (xmlLizable instanceof XMLizable) {
// Trace.trace("*** XMLizable: CpeDescription ***");
// Trace.trace("XMLizable: " + xmlLizable.getClass().getName());
if (uimaApp == null) {
uimaApp = UimaApplication_Impl.createUimaApplication (rm);
}
uimaApp.addXMLizable(xmlFile, (XMLizable) xmlLizable);
// } else {
// Trace.trace("XMLizable: " + xmlLizable.getClass().getName());
}
// Trace.trace("XMLizable: " + xmlLizable.getClass().getName());
return uimaApp;
}
static public AbstractUimaCasProcessor createUimaComponent (String xmlDescriptor)
throws InvalidXMLException,
ResourceInitializationException, IOException
{
XMLizable xmlizable = UimaXmlParsingUtil.parseUimaXmlDescriptor (xmlDescriptor);
if (xmlizable == null) {
return null;
}
UimaCasProcessor_impl u = new UimaCasProcessor_impl();
u.xmlizableDescriptor = xmlizable;
u.xmlDescriptor = xmlDescriptor; // Xml descriptor
if (xmlizable instanceof AnalysisEngineDescription) {
AnalysisEngineMetaData a = ((AnalysisEngineDescription) xmlizable).getAnalysisEngineMetaData();
u.setCasProcessorCategory(UimaCasProcessor.CASPROCESSOR_CAT_AE);
u.setInstanceName(a.getName());
u.configParamDecls = a.getConfigurationParameterDeclarations();
u.configParamSettings = a.getConfigurationParameterSettings();
// u.typePriorities = getTypePriorities(xmlizable, u.getResourceManager());
} else if (xmlizable instanceof CasConsumerDescription) {
ProcessingResourceMetaData p = ((CasConsumerDescription) xmlizable).getCasConsumerMetaData();
u.setCasProcessorCategory(UimaCasProcessor.CASPROCESSOR_CAT_CAS_CONSUMER);
u.setInstanceName(p.getName());
u.configParamDecls = p.getConfigurationParameterDeclarations();
u.configParamSettings = p.getConfigurationParameterSettings();
} else if (xmlizable instanceof URISpecifier) {
URISpecifier uriSpecifier = (URISpecifier) xmlizable;
// Trace.err("URISpecifier protocol=" + uriSpecifier.getProtocol()
// + " resource type=" + uriSpecifier.getResourceType()
// + " uri=" + uriSpecifier.getUri());
u.setCasProcessorCategory(UimaCasProcessor.CASPROCESSOR_CAT_SERVICE);
// Create a name from URI
String name = "Unknow";
try {
name = new URI(uriSpecifier.getUri()).getPath();
} catch (URISyntaxException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
u.setInstanceName(name);
// } else {
// Trace.err("UNKNOWN Descriptor: " + xmlizable.getClass().getName());
}
u.configParamsModel = new ConfigParametersModel(u.configParamDecls, u.configParamSettings, null);
return u;
}
/*************************************************************************/
static public TypePriorities getAnalysisEngineTypePriorities (XMLizable xmlizable, ResourceManager rm)
throws InvalidXMLException, ResourceInitializationException
{
TypePriorities tp = null;
if (xmlizable instanceof AnalysisEngineDescription) {
AnalysisEngineDescription ae = (AnalysisEngineDescription) xmlizable;
if ( ae.isPrimitive() ) {
AnalysisEngineMetaData a = ((AnalysisEngineDescription) xmlizable).getAnalysisEngineMetaData();
tp = ae.getAnalysisEngineMetaData().getTypePriorities();
} else {
// Aggregate AE
if (rm != null) {
tp = CasCreationUtils.mergeDelegateAnalysisEngineTypePriorities(ae, rm);
} else {
tp = CasCreationUtils.mergeDelegateAnalysisEngineTypePriorities(ae);
}
}
if (tp != null) {
if (rm != null) {
tp.resolveImports(rm);
} else {
tp.resolveImports();
}
// Trace.err(ae.getAnalysisEngineMetaData().getName() + ": HAS Type priorities");
try {
tp.toXML(System.out);
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// } else {
// Trace.err(ae.getAnalysisEngineMetaData().getName() + ": NO Type priorities");
}
}
return tp;
}
public TypePriorities getMergedTypePriorities ()
throws InvalidXMLException, ResourceInitializationException
{
TypePriorities mergedTp = null;
TypePriorities tp;
List typePrioritiesList = new ArrayList();
// Add Collection Reader
String aCollectionReaderPath = "";
List list = getUimaCollectionReaders();
CpeCollectionReader cr = null;
if (list != null && list.size() > 0) {
CollectionReaderDescription crDescr
= (CollectionReaderDescription) ((UimaCollectionReader) list.get(0)).getXmlizable();
if (crDescr != null) {
tp = crDescr.getCollectionReaderMetaData().getTypePriorities();
if (tp != null) {
typePrioritiesList.add(tp);
}
// } else {
// Trace.bug("CR doesn't have XMLizable");
}
}
// Add Cas Processors (AE, Cas Consumer)
list = getUimaCasProcessors();
for (int i=0; i<list.size(); ++i) {
UimaCasProcessor u = (UimaCasProcessor) list.get(i);
XMLizable specifier = ((UimaCasProcessor_impl) u).getXmlizable();
if (specifier == null) {
// Trace.bug("UimaCasProcessor " + u.getInstanceName() + " doesn't have XMLizable");
continue;
}
tp = getAnalysisEngineTypePriorities(specifier, getResourceManager());
if (tp != null) {
typePrioritiesList.add(tp);
}
}
// Merge typePrioritiesList
if (typePrioritiesList.size() > 0) {
mergedTp = CasCreationUtils.mergeTypePriorities(typePrioritiesList, getResourceManager());
}
return mergedTp;
} // getMergedTypePriorities
/*************************************************************************/
final static private int CPE_DEFAULT_BATCHSIZE = 10000;
// Current directory used to find "include" in CPE
private String currentDir = null;
private transient ResourceManager resourceManager;
public void setCurrentDirectory (String currDir) {
currentDir = currDir;
}
public ResourceManager getResourceManager () {
return resourceManager;
}
public void setResourceManager (ResourceManager rm)
{
this.resourceManager = rm;
}
public String generateUimaApplicationXmlDescriptor (String xmlDescriptorFileName, boolean resolve)
{
StringWriter w = new StringWriter();
FileOutputStream out = null;
try {
// Save to file
if (xmlDescriptorFileName != null && xmlDescriptorFileName.trim().length() > 0) {
out = new FileOutputStream (xmlDescriptorFileName);
this.toXML(out);
// Trace.trace("*** write UIMA App Xml to file: " + xmlDescriptorFileName);
}
// Return String
this.toXML(w);
// Trace.err(prettyPrintModel(this));
//System.out.println(w.toString());
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return w.toString();
}
public String generateCpeXmlDescriptor (String outputXmlDescriptorFileName, boolean resolve)
throws CpeDescriptorException, SAXException, IOException
{
StringWriter w = new StringWriter();
// Create a empty CpeDescription
CpeDescription cpeDesc = CpeDescriptorFactory.produceDescriptor();
// Add Collection Reader
List list = getUimaCollectionReaders();
if (list != null && list.size() > 0) {
String aCollectionReaderPath = "";
CpeCollectionReader cr = null;
aCollectionReaderPath = ((UimaCollectionReader)list.get(0)).getXmlDescriptor();
if (resolve) {
cr = cpeDesc.addCollectionReader(resolveUimaXmlDescriptor(aCollectionReaderPath));
} else {
cr = cpeDesc.addCollectionReader(aCollectionReaderPath);
}
// Add Configuration Parameter Overrides for CPE
UimaCollectionReader ucr = (UimaCollectionReader)list.get(0);
if (ucr.getConfigParamsModel() != null) {
List cpeOverrideList = ucr.getConfigParamsModel().getCpeParamModelList();
if (cpeOverrideList != null && cpeOverrideList.size() > 0) {
CasProcessorConfigurationParameterSettings settings =
CpeDescriptorFactory.produceCasProcessorConfigurationParameterSettings();
cr.setConfigurationParameterSettings(settings);
for (int k=0; k<cpeOverrideList.size(); ++k) {
ConfigParameterModel m = (ConfigParameterModel) cpeOverrideList.get(k);
if (m.getCpeValue() != null) {
settings.setParameterValue (m.getName(), m.getCpeValue());
}
}
}
}
}
// Add CAS Initializer
list = getUimaCasInitializers();
if (list != null && list.size() > 0) {
String aCasInitializerPath = "";
CpeCollectionReaderCasInitializer ci = null;
aCasInitializerPath = ((UimaCasInitializer)list.get(0)).getXmlDescriptor();
if (resolve) {
ci = cpeDesc.addCasInitializer(resolveUimaXmlDescriptor(aCasInitializerPath));
} else {
ci = cpeDesc.addCasInitializer(aCasInitializerPath);
}
// Trace.err("Add Cas Init: " + aCasInitializerPath);
// Add Configuration Parameter Overrides for CPE
UimaCasInitializer uci = (UimaCasInitializer)list.get(0);
if (uci.getConfigParamsModel() != null) {
List cpeOverrideList = uci.getConfigParamsModel().getCpeParamModelList();
if (cpeOverrideList != null && cpeOverrideList.size() > 0) {
CasProcessorConfigurationParameterSettings settings =
CpeDescriptorFactory.produceCasProcessorConfigurationParameterSettings();
ci.setConfigurationParameterSettings(settings);
for (int k=0; k<cpeOverrideList.size(); ++k) {
ConfigParameterModel m = (ConfigParameterModel) cpeOverrideList.get(k);
if (m.getCpeValue() != null) {
settings.setParameterValue (m.getName(), m.getCpeValue());
}
}
}
}
}
// Add Cas Processors (AE, Cas Consumer)
list = getUimaCasProcessors();
for (int i=0; i<list.size(); ++i) {
UimaCasProcessor u = (UimaCasProcessor) list.get(i);
CpeCasProcessor casProc;
// if (u.getCasProcessorCategory() == UimaCasProcessor.CASPROCESSOR_CAT_SERVICE) {
// casProc = CpeDescriptorFactory.produceRemoteCasProcessor(u.getInstanceName());
// } else {
// casProc = CpeDescriptorFactory.produceCasProcessor(u.getInstanceName());
// }
casProc = CpeDescriptorFactory.produceCasProcessor(u.getInstanceName());
if (resolve) {
casProc.setDescriptor(resolveUimaXmlDescriptor(u.getXmlDescriptor()));
} else {
casProc.setDescriptor(u.getXmlDescriptor());
}
// Add Error Handlings
if (u.getCasProcessorErrorHandling() != null) {
setCasProcessorErrorHandling(casProc, u.getCasProcessorErrorHandling());
} else {
// Set values from default, if any
// setCasProcessorErrorHandling(casProc, getDefaultCasProcessorSettings().getErrorHandling());
}
// Set <checkpoint batch="10000"/>
if (u.getBatchSize() != -1) {
casProc.setBatchSize(u.getBatchSize());
} else {
// Check if default value is defined
if (getDefaultCasProcessorSettings().getCasProcBatchSize() != -1) {
casProc.setBatchSize(getDefaultCasProcessorSettings().getCasProcBatchSize());
}
}
// Add Configuration Parameter Overrides for CPE
List cpeOverrideList = u.getConfigParamsModel().getCpeParamModelList();
if (cpeOverrideList != null && cpeOverrideList.size() > 0) {
CasProcessorConfigurationParameterSettings settings =
CpeDescriptorFactory.produceCasProcessorConfigurationParameterSettings();
casProc.setConfigurationParameterSettings(settings);
for (int k=0; k<cpeOverrideList.size(); ++k) {
ConfigParameterModel m = (ConfigParameterModel) cpeOverrideList.get(k);
if (m.getCpeValue() != null) {
settings.setParameterValue (m.getName(), m.getCpeValue());
}
}
}
// // Add Error Handlings
//CasProcessorErrorHandling errorHandling = u.getCasProcessorErrorHandling();
// if (errorHandling != null) {
// casProc.setTimeout(errorHandling.getTimeout().get());
// }
// Add to CPE
cpeDesc.addCasProcessor(casProc);
}
// Set CpeConfiguration from "existing" CpeConfiguration
CpeConfiguration cpeConfiguration = getCpeConfiguration();
if (cpeConfiguration == null) {
// Trace.bug("getCpeConfiguration() == null (NEVER SET ?)");
} else {
cpeDesc.getCpeConfiguration().setNumToProcess(cpeConfiguration.getNumToProcess());
cpeDesc.getCpeConfiguration().setDeployment(cpeConfiguration.getDeployment());
cpeDesc.getCpeConfiguration().getCheckpoint()
.setFrequency(cpeConfiguration.getCheckpoint().getFrequency(),
cpeConfiguration.getCheckpoint().isTimeBased());
}
// Set CpeCasProcessors Settings
// Trace.trace("************* Set CpeCasProcessors Settings ************");
if (cpeDesc.getCpeCasProcessors() != null) {
cpeDesc.getCpeCasProcessors().setPoolSize(cpeCasProcessorsSettings.getCasPoolSize());
} else {
// Trace.err("cpeDesc.getCpeCasProcessors() == null");
}
cpeDesc.setProcessingUnitThreadCount(cpeCasProcessorsSettings.getProcessingUnitThreadCount());
((CpeCasProcessorsImpl) cpeDesc.getCpeCasProcessors()).setDropCasOnException(cpeCasProcessorsSettings.isDropCasOnException());
FileOutputStream out = null;
try {
// Save to file
if (outputXmlDescriptorFileName != null && outputXmlDescriptorFileName.trim().length() > 0) {
out = new FileOutputStream (outputXmlDescriptorFileName);
cpeDesc.toXML(out);
// Trace.trace("*** write to file: " + outputXmlDescriptorFileName);
}
// Return String
((CpeDescriptionImpl) cpeDesc).toXML(w);
// Trace.err(prettyPrintModel(this));
//System.out.println(w.toString());
} catch (SAXException e) {
e.printStackTrace();
throw e;
} catch (IOException e) {
e.printStackTrace();
throw e;
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
throw e;
}
}
}
return w.toString();
} // generateCpeXmlDescriptor
public int generateTypeSystemXmlDescriptor (String xmlFileName)
{
TypeSystemDescription tsd = getTypeSystemDescription ();
FileOutputStream out = null;
try {
// Save to file
if (xmlFileName != null && xmlFileName.trim().length() > 0) {
out = new FileOutputStream (xmlFileName);
tsd.toXML(out);
// Trace.trace("*** write to file: " + xmlFileName);
}
} catch (SAXException e) {
e.printStackTrace();
return -1;
} catch (IOException e) {
e.printStackTrace();
return -2;
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
return -3;
}
}
}
return 0;
}
/*************************************************************************/
/**
* Return true if the ResourceSpecifier is CasConsumerDescription
*
* @param specifier
* @return
* @return boolean
*/
// Copy from CpeDescriptorModel
private boolean isCasConsumerSpecifier(ResourceSpecifier specifier)
{
if (specifier instanceof CasConsumerDescription) {
return true;
} else if (specifier instanceof URISpecifier) {
URISpecifier uriSpec = (URISpecifier)specifier;
return URISpecifier.RESOURCE_TYPE_CAS_CONSUMER.equals(uriSpec.getResourceType());
}
return false;
}
/*************************************************************************/
/* compare CasProcessorErrorHandling */
/*************************************************************************/
public boolean compareWithDefaultCasProcessorErrorRateThreshold
(CasProcessorErrorRateThreshold threshold1, CasProcessorErrorRateThreshold threshold2)
{
if (threshold1.getMaxErrorCount() != threshold2.getMaxErrorCount()) {
return false;
}
if (threshold1.getMaxErrorSampleSize() != threshold2.getMaxErrorSampleSize()) {
return false;
}
if (!threshold1.getAction().equalsIgnoreCase(threshold2.getAction())) {
return false;
}
return true;
}
public boolean compareWithDefaultCasProcessorMaxRestarts
(CasProcessorMaxRestarts maxRestart1, CasProcessorMaxRestarts maxRestart2)
{
if (maxRestart1.getRestartCount() != maxRestart2.getRestartCount()) {
return false;
}
if (!maxRestart1.getAction().equalsIgnoreCase(maxRestart2.getAction())) {
return false;
}
return true;
}
/**
* Compare with default settings for each Cas Processor.
* If the default value is NOT set, use the CPE's default settings
*
* @param errorHandling
* @return
* @return boolean
*/
public boolean compareWithCpeDefaultErrorHandling (CasProcessorErrorHandling errorHandling)
{
CasProcessorErrorHandling def = null;
if (defaultCasProcessorSettings != null) {
def = defaultCasProcessorSettings.getErrorHandling();
}
if (def == null) {
// Use CPE's default value
def = cpeDefaultErrorHandling;
}
if (def != null) {
if (!compareWithDefaultCasProcessorErrorRateThreshold(errorHandling.getErrorRateThreshold(),
def.getErrorRateThreshold())) {
return false;
}
if (!compareWithDefaultCasProcessorMaxRestarts(errorHandling.getMaxConsecutiveRestarts(),
def.getMaxConsecutiveRestarts())) {
return false;
}
if (errorHandling.getTimeout().get() != def.getTimeout().get()) {
return false;
}
} else {
Trace.bug("Cannot get CpeDefaultErrorHandling");
return false;
}
return true;
}
/*************************************************************************/
/* Add CPE Xml Descriptor (CpeDescription) */
/*************************************************************************/
// public void addCasProcessor (String cpeXml, CpeDescription cpeDescription)
// throws InvalidXMLException, ResourceInitializationException, CpeDescriptorException
// {
// cpeHref = cpeXml;
// // Trace.trace("cpeXml: " + cpeXml);
// addCasProcessorsFromCpeDescription(cpeDescription);
// }
// 07-16-2007
// Remove the code that does duplicate operations when adding Collection Reader
// and CasProcessors
// Note: Look at "addCpeDescription" by searching for testIt flag
public void addCpeDescription (String cpeXml, CpeDescription cpeDescription)
throws InvalidXMLException, ResourceInitializationException,
CpeDescriptorException
{
int error = 0, details = 0; // Status of each node
cpeHref = cpeXml;
// Set CPE Configuration Settings if NOT set
try {
if (cpeConfiguration != null) {
cpeConfiguration = cpeDescription.getCpeConfiguration();
}
} catch (CpeDescriptorException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// Collection Reader
CpeCollectionReader[] collRdrs = null;
try {
collRdrs = cpeDescription.getAllCollectionCollectionReaders();
} catch (CpeDescriptorException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
boolean testIt = false; // FOR TESTING
if (testIt && collRdrs != null && collRdrs.length>0) {
for (int i=0; i<collRdrs.length; ++i) {
// Create a NEW UimaCollectionReader for its Xml descriptor
CpeComponentDescriptor cpeComponentDescriptor = collRdrs[i].getDescriptor();
String xml = null;
if (cpeComponentDescriptor.getInclude() != null) {
xml = cpeComponentDescriptor.getInclude().get();
} else if (cpeComponentDescriptor.getImport() != null) {
xml = cpeComponentDescriptor.getImport().getLocation();
if (xml == null) {
xml = cpeComponentDescriptor.getImport().getName();
}
}
if (xml == null || xml.trim().length() == 0) {
// EMPTY Collection Reader
// Trace.err("EMPTY Collection Reader");
continue;
}
String newFileLocation = xml;
String resolvedFileName = UimaApplication_Impl.resolveUimaXmlDescriptor(xml);
if (resolvedFileName == null) {
// Cannot resolve
// Trace.err("cannot resolve file: " + resolvedFileName);
} else {
File f = new File(resolvedFileName);
if ( !f.isAbsolute() ) {
// Relative path
if ( ! f.exists() ) {
// Can NOT find file.
// Try to find it within CURRENT DIRECTORY
f = new File (currentDir, resolvedFileName);
if ( ! f.exists() ) {
Trace.trace("*** ERROR: Cannot find file: " + resolvedFileName);
error = STATUS_DEPLOYMENT_NODE_ERROR;
details = STATUS_DETAILS_FILE_NOT_FOUND;
}
resolvedFileName = f.getAbsolutePath();
newFileLocation = resolvedFileName;
}
// Trace.trace("+++ New xml:" + resolvedFileName);
}
}
UimaCollectionReader u = UimaCollectionReader.createUimaCasProcessor (collRdrs[i],
newFileLocation/*resolvedFileName*/, this);
// Need to check duplication
// UimaCasProcessor u = getUimaCasProcessor(collRdrs[i].getName());
// if (u != null) {
// UimaCasProcessor_impl.createUimaCasProcessorFrom(u, casProcs[i], specifier, this);
// } else {
// u = UimaCasProcessor_impl.createUimaCasProcessor(casProcs[i], specifier, this);
// uimaCasProcessors.add(u);
// }
if (error > 0) {
u.setStatus(error);
u.setStatusDetails(details);
}
uimaCollectionReaders.add(u);
} // for
// ONLY 1 Cas Initializer is allowed (Also true for Collection Reader)
CpeCollectionReaderCasInitializer casInit = null;
try {
casInit = collRdrs[0].getCasInitializer();
} catch (CpeDescriptorException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (casInit != null) {
// Create a NEW UimaCasInitializer for its Xml descriptor
String xml = casInit.getDescriptor().getInclude().get();
if (xml == null || xml.trim().length() == 0) {
// EMPTY Cas Initializer
// Trace.err("EMPTY Cas Initializer");
} else {
String newFileLocation = xml;
String resolvedFileName = resolveUimaXmlDescriptor(xml);
File f = new File(resolvedFileName);
error = 0;
details = 0;
if ( !f.isAbsolute() ) {
// Relative path
if ( ! f.exists() ) {
// Can NOT find file.
// Try to find it within CURRENT DIRECTORY
f = new File (currentDir, resolvedFileName);
if ( ! f.exists() ) {
// Trace.trace("*** ERROR: Cannot find file: " + resolvedFileName);
error = STATUS_DEPLOYMENT_NODE_ERROR;
details = STATUS_DETAILS_FILE_NOT_FOUND;
}
resolvedFileName = f.getAbsolutePath();
newFileLocation = resolvedFileName;
}
// Trace.trace("+++ New xml:" + resolvedFileName);
}
UimaCasInitializer u = UimaCasInitializer.createUimaCasProcessor (casInit,
newFileLocation/*resolvedFileName*/, this);
if (error > 0) {
u.setStatus(error);
u.setStatusDetails(details);
}
uimaCasInitializers.add(u);
}
}
}
/*****************************************************************/
if (cpeCasProcessorsSettings == null) {
cpeCasProcessorsSettings = new CpeCasProcessorsSettings();
}
try {
cpeCasProcessorsSettings.setCasPoolSize(((CpeCasProcessorsImpl) cpeDescription.getCpeCasProcessors()).getPoolSize());
// Cannot get processingUnitThreadCount
cpeCasProcessorsSettings.setDropCasOnException(((CpeCasProcessorsImpl) cpeDescription.getCpeCasProcessors()).getDropCasOnException());
} catch (CpeDescriptorException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// CPE Cas Processors
CpeCasProcessor[] casProcs = null;
try {
casProcs = cpeDescription.getCpeCasProcessors().getAllCpeCasProcessors();
} catch (CpeDescriptorException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (casProcs == null) {
// Empty Cpe Descriptor
return ;
}
// Get list of CpeCasProcessor which can be an AE or a Cas Consumer
// For each CpeCasProcessor, get its type system (insert in cpeModel.typeSystemList)
// cpeModel.cpeCasProcessorModelList = new ArrayList();
// List specifierList = new ArrayList();
// List aeList = new ArrayList();
// List consumerList = new ArrayList();
// cpeModel.typeSystemList = new ArrayList();
for (int i=0; i < casProcs.length; i++) {
CpeComponentDescriptor cpeComponentDescriptor = casProcs[i].getCpeComponentDescriptor();
String newFileLocation = null;
if (cpeComponentDescriptor.getInclude() != null) {
newFileLocation = cpeComponentDescriptor.getInclude().get();
} else if (cpeComponentDescriptor.getImport() != null) {
newFileLocation = cpeComponentDescriptor.getImport().getLocation();
if (newFileLocation == null) {
newFileLocation = cpeComponentDescriptor.getImport().getName();
}
}
String specifierFile = resolveUimaXmlDescriptor(newFileLocation);
ResourceSpecifier specifier = null;
// Check for file existence
if ( specifierFile == null || specifierFile.trim().length() == 0 ) {
// Trace.err("EMPTY (no xml desc) Cas Processor " + casProcs[i].getName());
continue;
} else {
File f = new File(specifierFile);
error = 0;
details = 0;
if ( !f.isAbsolute() ) {
// Relative path
if ( ! f.exists() ) {
// Can NOT find file.
// Try to find it within CURRENT DIRECTORY
f = new File (currentDir, specifierFile);
if ( ! f.exists() ) {
// Trace.err("*** ERROR: Cannot find file: " + specifierFile);
error = STATUS_DEPLOYMENT_NODE_ERROR;
details = STATUS_DETAILS_FILE_NOT_FOUND;
// continue;
}
specifierFile = f.getAbsolutePath();
newFileLocation = specifierFile;
}
} else {
// Absolute Path
if ( ! f.exists() ) {
// Trace.err ("Cannot find xml file for " + casProcs[i].getName()
// + ": " + specifierFile);
error = STATUS_DEPLOYMENT_NODE_ERROR;
details = STATUS_DETAILS_FILE_NOT_FOUND;
// continue;
}
}
if (error == 0) {
// No error.
try {
specifier = UIMAFramework.getXMLParser().
parseResourceSpecifier(new XMLInputSource(specifierFile));
} catch (InvalidXMLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
continue;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
continue;
}
}
}
// if (specifier != null) {
// specifierList.add(specifier);
//
// if (isCasConsumerSpecifier(specifier)) {
// consumerList.add(specifier);
// } else {
// aeList.add(specifier);
// }
// }
// Need to check duplication
UimaCasProcessor u = getUimaCasProcessor(casProcs[i].getName());
if (u != null) {
Trace.err("Duplicate with CasProcessor from CPE: " + casProcs[i].getName());
// Should we call the following code ?
if (testIt) {
UimaCasProcessor_impl.createUimaCasProcessorFrom(u, casProcs[i], specifier, this);
} else {
u.setCpeCasProcessor(casProcs[i]);
}
} else {
u = UimaCasProcessor_impl.createUimaCasProcessor(casProcs[i], specifier, this);
uimaCasProcessors.add(u);
}
if (error > 0) {
u.setStatus(error);
u.setStatusDetails(details);
}
// File path may be changed
// ((AbstractUimaCasProcessor) u).setXmlDescriptor(specifierFile);
((AbstractUimaCasProcessor) u).setXmlDescriptor(newFileLocation);
// Get CasProcessorErrorHandling
if (cpeDefaultErrorHandling == null) {
// Trace.bug("NO pre-setting for cpeDefaultErrorHandling");
cpeDefaultErrorHandling = CpeDescriptorFactory.produceCasProcessorErrorHandling();
}
// printErrorHandling(cpeDefaultErrorHandling);
if ( ! compareWithCpeDefaultErrorHandling(casProcs[i].getErrorHandling()) ) {
// Not the same values as CPE defaults
u.setCasProcessorErrorHandling(casProcs[i].getErrorHandling());
}
u.setBatchSize(casProcs[i].getBatchSize());
// Get type system
// cpeModel.typeSystemList.add(getTypeSystemDescription(specifier));
} // for
} // addCpeDescription
/*************************************************************************/
/* Add Collection Reader or Cas Processor */
/**
* @throws ResourceInitializationException
* @throws InvalidXMLException
* ***********************************************************************/
public Object addXMLizable (String xmlizableXmlFile, XMLizable xmlizable)
throws InvalidXMLException, ResourceInitializationException, CpeDescriptorException
{
Object component = null;
// Create a NEW CpeCasProcessor
// CPE BUG!!! Need to call CpeDescriptorFactory.produceDescriptor();
// CpeDescription cpeDesc = CpeDescriptorFactory.produceDescriptor();
// Trace.trace("xmlizableXmlFile:" + xmlizableXmlFile);
if (xmlizable instanceof CollectionReaderDescription) {
UimaCollectionReader u = UimaCollectionReader
.createUimaCasProcessor ((CollectionReaderDescription) xmlizable,
xmlizableXmlFile, this);
uimaCollectionReaders.add(u);
component = u;
} else if (xmlizable instanceof CasInitializerDescription) {
// Trace.err("CasInitializerDescription");
UimaCasInitializer ci = UimaCasInitializer
.createUimaCasProcessor ((CasInitializerDescription) xmlizable,
xmlizableXmlFile, this);
uimaCasInitializers.add(ci);
component = ci;
} else if (xmlizable instanceof CpeDescription) {
addCpeDescription(xmlizableXmlFile, (CpeDescription) xmlizable);
component = this;
} else {
CpeCasProcessor cpeCasProcessor;
// if (xmlizable instanceof URISpecifier) {
// cpeCasProcessor = CpeDescriptorFactory.produceRemoteCasProcessor("xmlizableXmlFile");
// } else {
// cpeCasProcessor = CpeDescriptorFactory.produceCasProcessor("xmlizableXmlFile");
// }
cpeCasProcessor = CpeDescriptorFactory.produceCasProcessor("xmlizableXmlFile");
cpeCasProcessor.setDescriptor(xmlizableXmlFile);
UimaCasProcessor u = UimaCasProcessor_impl.createUimaCasProcessor(cpeCasProcessor,
xmlizable, this);
uimaCasProcessors.add(u);
// Reset cpeCasProcessor's name
cpeCasProcessor.setName(u.getInstanceName());
component = u;
}
return component;
} // addXMLizable
/**
* Check if the specified is valid for addition
*
*/
static public boolean isValidXMLizableComponent (XMLizable xmlizable)
{
if (xmlizable instanceof CollectionReaderDescription
|| xmlizable instanceof CasInitializerDescription
|| xmlizable instanceof AnalysisEngineDescription
|| xmlizable instanceof TaeDescription
|| xmlizable instanceof CasConsumerDescription
|| xmlizable instanceof URISpecifier
|| xmlizable instanceof CustomResourceSpecifier
|| xmlizable instanceof CpeDescription) {
return true;
}
return false;
}
/*************************************************************************/
public UimaCollectionReader getUimaCollectionReader ()
{
if (uimaCollectionReaders != null && uimaCollectionReaders.size() > 0) {
return (UimaCollectionReader)uimaCollectionReaders.get(0);
}
return null;
} // getUimaCollectionReader
public UimaCollectionReader getUimaCollectionReader (String name)
{
if (uimaCollectionReaders != null) {
for (int i=0; i<uimaCollectionReaders.size(); ++i) {
if (name.equalsIgnoreCase(((UimaCollectionReader)uimaCollectionReaders.get(i)).getInstanceName())) {
return (UimaCollectionReader)uimaCollectionReaders.get(i);
}
}
}
return null;
} // getUimaCollectionReader
public UimaCasProcessor getUimaCasProcessor (String name)
{
if (uimaCasProcessors != null) {
for (int i=0; i<uimaCasProcessors.size(); ++i) {
if (name.equalsIgnoreCase(((UimaCasProcessor)uimaCasProcessors.get(i)).getInstanceName())) {
return (UimaCasProcessor)uimaCasProcessors.get(i);
}
}
}
return null;
} // getUimaCasProcessor
public boolean deleteUimaCasProcessor (AbstractUimaCasProcessor u)
{
List list;
if (u.isUimaCollectionReader()) {
list = uimaCollectionReaders;
} else if (u.isUimaCasInitializer()) {
list = uimaCasInitializers;
} else {
list = uimaCasProcessors;
}
for (int i=0; i<list.size(); ++i) {
if (u == list.get(i)) {
list.remove(i);
return true;
}
}
// Trace.bug("CANNOT find for deletion: " + u.getInstanceName());
return false;
} // deleteUimaCasProcessor
public boolean moveUimaCasProcessor (AbstractUimaCasProcessor u, boolean moveUp)
{
List list;
if (u.isUimaCollectionReader()) {
list = uimaCollectionReaders;
} else {
list = uimaCasProcessors;
}
int index = list.indexOf(u);
if (moveUp) {
// Move Up if NOT 1st element
if (index != 0) {
list.remove(index);
list.add(index-1, u);
return true;
}
} else {
// Move Down if NOT last element
if (index != (list.size()-1)) {
list.remove(index);
list.add(index+1, u);
return true;
}
}
return false;
}
/**
* Check if AbstractUimaCasProcessor is movable
*
* @param u
* @return int 0: non-movable; 0x01: up; 0x02: down; 0x003; both dir
*/
public int isMovable (AbstractUimaCasProcessor u)
{
List list;
if (u.isUimaCollectionReader()) {
list = uimaCollectionReaders;
} else if (u.isUimaCasInitializer()) {
list = uimaCasInitializers;
} else {
list = uimaCasProcessors;
}
int index = list.indexOf(u);
int flags = 0;
// Move Up if NOT 1st element
if (index != 0) {
flags = 0x01;
}
// Move Down if NOT last element
if (index != (list.size()-1)) {
flags = flags | 0x02;
}
return flags;
}
public boolean deleteUimaCasProcessor_1 (UimaCasProcessor u)
{
for (int i=0; i<uimaCasProcessors.size(); ++i) {
if (u == uimaCasProcessors.get(i)) {
uimaCasProcessors.remove(i);
// Trace.trace("Delete " + u.getInstanceName());
return true;
}
}
Trace.bug("CANNOT find for deletion: " + u.getInstanceName());
return false;
} // deleteUimaCasProcessor
public boolean moveUimaCasProcessor_1 (UimaCasProcessor u, boolean moveUp)
{
int index = uimaCasProcessors.indexOf(u);
if (moveUp) {
// Move Up if NOT 1st element
if (index != 0) {
uimaCasProcessors.remove(index);
uimaCasProcessors.add(index-1, u);
return true;
}
} else {
// Move Down if NOT last element
if (index != (uimaCasProcessors.size()-1)) {
uimaCasProcessors.remove(index);
uimaCasProcessors.add(index+1, u);
return true;
}
}
return false;
}
/*************************************************************************/
public String prettyPrintModel (XMLizable trueDescriptor) {
StringWriter writer = new StringWriter();
String parsedText = null;
try {
XMLSerializer xmlSerializer = new XMLSerializer(true);
xmlSerializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
xmlSerializer.setWriter(writer);
ContentHandler contentHandler = xmlSerializer.getContentHandler();
contentHandler.startDocument();
if (trueDescriptor instanceof AnalysisEngineDescription) {
AnalysisEngineDescription aed = (AnalysisEngineDescription) trueDescriptor;
aed.toXML(contentHandler, true, true);
} else {
trueDescriptor.toXML(contentHandler, true);
}
contentHandler.endDocument();
writer.close();
parsedText = writer.toString();
} catch (SAXException e) {
// throw new InternalErrorCDE(Messages.getString("MultiPageEditor.22"), e); //$NON-NLS-1$
} catch (IOException e) {
// throw new InternalErrorCDE(Messages.getString("MultiPageEditor.23"), e); //$NON-NLS-1$
}
return parsedText;
}
/*************************************************************************/
/**
* Overridden to provide custom XML representation.
* @see org.apache.uima.util.XMLizable#toXML(ContentHandler)
*/
public void toXML(ContentHandler aContentHandler,
boolean aWriteDefaultNamespaceAttribute)
throws SAXException
{
AttributesImpl attrs = new AttributesImpl();
aContentHandler.startElement(getXmlizationInfo().namespace,
"uimaApplication", "uimaApplication", attrs);
if (getCpeDescriptor() != null){
attrs.addAttribute("","href", "href", null, getCpeDescriptor());
}
aContentHandler.startElement(getXmlizationInfo().namespace,
"", "cpeDescription", attrs);
aContentHandler.endElement(getXmlizationInfo().namespace,
"", "cpeDescription");
attrs.clear();
aContentHandler.startElement(getXmlizationInfo().namespace,
"", TAG_DEPLOYMENT_DEFAULT_SETTINGS, attrs);
/*
<errorHandling>
<errorRateThreshold action="terminate" count="100" sample_size=1000"/>
<maxConsecutiveRestarts action="terminate" value="30"/>
<timeout max="10000"/>
</errorHandling>
<checkpoint batch="10000" frequency="" />
*/
aContentHandler.startElement(getXmlizationInfo().namespace,
"", "errorHandling", attrs);
attrs.clear();
CasProcessorErrorHandling errorHandling = getDefaultCasProcessorSettings().getErrorHandling();
if (errorHandling != null) {
attrs.addAttribute("","action","action",null,errorHandling.getErrorRateThreshold().getAction());
attrs.addAttribute("","count","count",null, ""+errorHandling.getErrorRateThreshold().getMaxErrorCount());
attrs.addAttribute("","sample_size","sample_size",null, ""+errorHandling.getErrorRateThreshold().getMaxErrorSampleSize());
aContentHandler.startElement(getXmlizationInfo().namespace,
"", "errorRateThreshold", attrs);
aContentHandler.endElement(getXmlizationInfo().namespace, "","errorRateThreshold");
}
aContentHandler.endElement(getXmlizationInfo().namespace,
"","errorHandling");
attrs.clear();
attrs.addAttribute("","batch","batch",null, ""+getDefaultCasProcessorSettings().getCasProcBatchSize());
aContentHandler.startElement(getXmlizationInfo().namespace,
"","checkpoint",attrs);
aContentHandler.endElement(getXmlizationInfo().namespace,
"","checkpoint");
aContentHandler.endElement(getXmlizationInfo().namespace,
"", TAG_DEPLOYMENT_DEFAULT_SETTINGS);
// Add Collection Reader)
List list = getUimaCollectionReaders();
for (int i=0; i<list.size(); ++i) {
((UimaCollectionReader) list.get(i)).toXML(aContentHandler,
aWriteDefaultNamespaceAttribute);
}
// Add Cas Initializer
list = getUimaCasInitializers();
for (int i=0; i<list.size(); ++i) {
attrs.clear();
UimaCasInitializer u = (UimaCasInitializer) list.get(i);
attrs.addAttribute("", TAG_NAME, TAG_NAME,
null, ""+u.getInstanceName());
aContentHandler.startElement(getXmlizationInfo().namespace,
"", TAG_DEPLOYMENT_OVERRIDES,attrs);
attrs.clear();
// <casProcessorSettings>
aContentHandler.startElement(getXmlizationInfo().namespace,
"", TAG_DEPLOYMENT_SETTINGS, attrs);
// </casProcessorSettings>
aContentHandler.endElement(getXmlizationInfo().namespace,
"", TAG_DEPLOYMENT_SETTINGS);
// Add Configuration Parameter Overrides for CPE
List cpeOverrideList = u.getConfigParamsModel().getCpeParamModelList();
if (cpeOverrideList != null && cpeOverrideList.size() > 0) {
// <configurationParameterSettings>
aContentHandler.startElement(getXmlizationInfo().namespace,
"","configurationParameterSettings",attrs);
CasProcessorConfigurationParameterSettings settings =
CpeDescriptorFactory.produceCasProcessorConfigurationParameterSettings();
// casProc.setConfigurationParameterSettings(settings);
for (int k=0; k<cpeOverrideList.size(); ++k) {
ConfigParameterModel m = (ConfigParameterModel) cpeOverrideList.get(k);
if (m.getCpeValue() != null) {
settings.setParameterValue (m.getName(), m.getCpeValue());
m.toXML(aContentHandler, aWriteDefaultNamespaceAttribute);
}
}
// </configurationParameterSettings>
aContentHandler.endElement(getXmlizationInfo().namespace,
"","configurationParameterSettings");
}
aContentHandler.endElement(getXmlizationInfo().namespace,
"", TAG_DEPLOYMENT_OVERRIDES);
}
// Add Cas Processors
list = getUimaCasProcessors();
for (int i=0; i<list.size(); ++i) {
((UimaCasProcessor) list.get(i)).toXML(aContentHandler,
aWriteDefaultNamespaceAttribute);
}
aContentHandler.endElement(getXmlizationInfo().namespace,
"uimaApplication","uimaApplication");
}
protected XmlizationInfo getXmlizationInfo() {
// return XMLIZATION_INFO;
return new XmlizationInfo(null, null);
//this object has custom XMLization routines
}
static final private XmlizationInfo XMLIZATION_INFO =
new XmlizationInfo("uimaApplication",
new PropertyXmlInfo[]{
new PropertyXmlInfo("cpeDescriptor", false),
new PropertyXmlInfo("defaultCasProcessorSettings", false)
});
/**
* Overridden to provide custom XMLization.
* @see org.apache.uima.util.XMLizable#buildFromXMLElement(org.w3c.dom.Element, org.apache.uima.util.XMLParser)
*/
public void buildFromXMLElement (Element aElement, XMLParser aParser, XMLParser.ParsingOptions aOptions)
throws InvalidXMLException
{
// Trace.trace();
NodeList childNodes = aElement.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Node curNode = childNodes.item(i);
if (curNode instanceof Element) {
Element elem = (Element)curNode;
if ("cpeDescription".equals(elem.getTagName())) {
setCpeDescriptor(elem.getAttribute("href"));
// Trace.trace("HRef: " + getCpeDescriptor());
} else if (TAG_COLLECTION_READER.equals(elem.getTagName())) {
uimaCollectionReaders.add(aParser.buildObject(elem, aOptions));
} else if (TAG_CAS_PROCESSOR.equals(elem.getTagName())) {
uimaCasProcessors.add(aParser.buildObject(elem, aOptions));
} else if (TAG_DEPLOYMENT_DEFAULT_SETTINGS.equals(elem.getTagName())) {
// defaultCasProcessorSettings ALWAYS exists
buildDefaultCasProcessorSettings(elem, aParser);
} else {
Trace.err("Unknown Tag: " + elem.getTagName());
// throw new InvalidXMLException(
// InvalidXMLException.UNKNOWN_ELEMENT,
// new Object[]{elem.getTagName()});
}
}
}
// UimaCasProcessor[] paramArr =
// new UimaCasProcessor[uimaCasProcessors.size()];
// if (uimaCasProcessors.size() > 0) {
// uimaCasProcessors.toArray(paramArr);
// }
// setUimaCasProcessors(paramArr);
}
private void buildCasProcessorSettingsOverride (Element aElement, XMLParser aParser)
throws InvalidXMLException
{
NodeList childNodes = aElement.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Node curNode = childNodes.item(i);
if (!(curNode instanceof Element)) {
continue;
}
Element elem = (Element)curNode;
if ("errorHandling".equals(elem.getTagName())) {
}
}
}
/**
*
*
* @param aElement
* @param aParser
* @throws InvalidXMLException
* @return void
*
* <defaultCasProcessorSettings>
* <errorHandling>
* <errorRateThreshold action="terminate" count="100" sample_size=1000"/>
* <maxConsecutiveRestarts action="terminate" value="30"/>
* <timeout max="10000"/>
* </errorHandling>
* <checkpoint batch="10000" frequency="" />
* </defaultCasProcessorSettings>
*
*/
private void buildDefaultCasProcessorSettings (Element aElement, XMLParser aParser)
throws InvalidXMLException
{
NodeList childNodes = aElement.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Node curNode = childNodes.item(i);
if (!(curNode instanceof Element)) {
continue;
}
Element elem = (Element)curNode;
if ("errorHandling".equals(elem.getTagName())) {
NodeList cNodes = elem.getChildNodes();
CasProcessorErrorHandling errorHandling = null;
for (int j = 0; j < cNodes.getLength(); j++) {
Node node = cNodes.item(j);
if (!(node instanceof Element)) {
continue;
}
Element e = (Element) node;
if ("errorRateThreshold".equals(e.getTagName())) {
if (errorHandling == null) {
errorHandling = UimaApplication_Impl.getCpeDefaultErrorHandling();
}
errorHandling.getErrorRateThreshold().setAction(e.getAttribute("action"));
errorHandling.getErrorRateThreshold().setMaxErrorCount(Integer.parseInt(e.getAttribute("count")));
errorHandling.getErrorRateThreshold().setMaxErrorSampleSize(Integer.parseInt(e.getAttribute("sample_size")));
// Trace.trace("errorRateThreshold action=" + action);
} else if ("maxConsecutiveRestarts".equals(e.getTagName())) {
if (errorHandling == null) {
errorHandling = UimaApplication_Impl.getCpeDefaultErrorHandling();
}
} else if ("timeout".equals(e.getTagName())) {
if (errorHandling == null) {
errorHandling = UimaApplication_Impl.getCpeDefaultErrorHandling();
}
}
}
// Set ErrorHandling ?
if (errorHandling != null) {
getDefaultCasProcessorSettings().setErrorHandling(errorHandling);
}
} else if ("checkpoint".equals(elem.getTagName())) {
} else {
throw new InvalidXMLException(
InvalidXMLException.UNKNOWN_ELEMENT,
new Object[]{elem.getTagName()});
}
}
}
/*************************************************************************/
/**
* Get UIMA application descriptor.
*
* @return String
*/
public String getCpeDescriptor ()
{
return cpeHref;
}
/**
* Set UIMA application descriptor.
*
* @param descriptor
* @return void
*/
public void setCpeDescriptor (String descriptor)
{
cpeHref = descriptor;
}
// public CpeDescriptorModel getCpeDescriptorModel ()
// {
// return mCpeDescriptorModel;
// }
public void test ()
{
// UimaCasProcessor[] sets = getUimaCasProcessors();
// for (int i=0; i<sets.length; ++i) {
// sets[i].printMe();
// ConfigurationParameterSettings[] settings = sets[i].getConfigurationParameterSettings();
// for (int k=0; k<settings.length; ++k) {
// // Trace.trace(settings[k].toString());
// }
// }
}
/**
* Initialize UimaCasProcessor from cpe descriptor
*
* @return void
*/
public void initUimaCasProcessors()
{
// if (mCpeDescriptorModel == null) return;
// for (int i=0; i<mUimaCasProcessors.length; ++i) {
// CpeCasProcessorModel model = mCpeDescriptorModel
// .getCpeCasProcessorModel(mUimaCasProcessors[i].getCasProcessorName());
// if (model != null) {
// ((UimaCasProcessor_impl)mUimaCasProcessors[i]).initConfigurationParameters(model);
// }
//
// }
}
// public void createUimaCasProcessors ()
// {
// List list = mCpeDescriptorModel.getCpeCasProcessorModelList();
// if (list == null || list.size() == 0) {
// return;
// }
// mUimaCasProcessors = new UimaCasProcessor[list.size()];
// for (int i=0; i<list.size(); ++i) {
// UimaCasProcessor_impl u = new UimaCasProcessor_impl();
// u.initConfigurationParameters((CpeCasProcessorModel) list.get(i));
// mUimaCasProcessors[i] = u;
// }
// }
/**
* Get all UIMA Collection Readers.
*
* @return An arry of UimaCollectionReader
*/
public List getUimaCollectionReaders() {
return uimaCollectionReaders;
}
public List getUimaCasInitializers() {
return uimaCasInitializers;
}
public List getUimaCasProcessors() {
return uimaCasProcessors;
}
/**
* @return Returns the cpeConfiguration.
*/
public CpeConfiguration getCpeConfiguration() {
return cpeConfiguration;
}
/**
* @param cpeConfiguration The cpeConfiguration to set.
*/
public void setCpeConfiguration(CpeConfiguration cpeConfiguration) {
this.cpeConfiguration = cpeConfiguration;
}
/**
* @return Returns the defaultCasProcessorSettings.
*/
public DefaultCasProcessorSettings getDefaultCasProcessorSettings() {
return defaultCasProcessorSettings;
}
/**
* @param defaultCasProcessorSettings The defaultCasProcessorSettings to set.
*/
public void setDefaultCasProcessorSettings(
DefaultCasProcessorSettings defaultCasProcessorSettings) {
this.defaultCasProcessorSettings = defaultCasProcessorSettings;
}
// public void setUimaCasProcessors(UimaCasProcessor[] aParams) {
// mUimaCasProcessors = aParams;
// }
// public UimaCasProcessor getUimaCasProcessor(String casProcessorName)
// {
// if (mUimaCasProcessors != null) {
// for (int i=0; i<mUimaCasProcessors.length; ++i) {
// if ( casProcessorName.equals(mUimaCasProcessors[i].getCasProcessorName()) ) {
// return mUimaCasProcessors[i];
// }
// }
// }
// return null;
// }
public void printMe()
{
Trace.out("Cpe xml:" + getCpeDescriptor());
}
/**
* @return Returns the cpeCasProcessorsSettings.
*/
public CpeCasProcessorsSettings getCpeCasProcessorsSettings() {
return cpeCasProcessorsSettings;
}
/**
* @param cpeCasProcessorsSettings The cpeCasProcessorsSettings to set.
*/
public void setCpeCasProcessorsSettings(
CpeCasProcessorsSettings cpeCasProcessorsSettings) {
this.cpeCasProcessorsSettings = cpeCasProcessorsSettings;
}
/**
* @return the runtimeContext
*/
public IRuntimeContext getRuntimeContext() {
return runtimeContext;
}
/**
* @param runtimeContext the runtimeContext to set
*/
public void setRuntimeContext(IRuntimeContext runtimeContext) {
this.runtimeContext = runtimeContext;
}
}