/*
* 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.analysis_engine.impl;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.apache.uima.Constants;
import org.apache.uima.UIMAFramework;
import org.apache.uima.analysis_engine.AnalysisEngine;
import org.apache.uima.analysis_engine.AnalysisEngineDescription;
import org.apache.uima.analysis_engine.metadata.AnalysisEngineMetaData;
import org.apache.uima.analysis_engine.metadata.CapabilityLanguageFlow;
import org.apache.uima.analysis_engine.metadata.FixedFlow;
import org.apache.uima.analysis_engine.metadata.FlowConstraints;
import org.apache.uima.analysis_engine.metadata.FlowControllerDeclaration;
import org.apache.uima.analysis_engine.metadata.SofaMapping;
import org.apache.uima.analysis_engine.metadata.impl.AnalysisEngineMetaData_impl;
import org.apache.uima.cas.CAS;
import org.apache.uima.resource.ResourceConfigurationException;
import org.apache.uima.resource.ResourceCreationSpecifier;
import org.apache.uima.resource.ResourceInitializationException;
import org.apache.uima.resource.ResourceManager;
import org.apache.uima.resource.ResourceSpecifier;
import org.apache.uima.resource.impl.ResourceCreationSpecifier_impl;
import org.apache.uima.resource.metadata.Capability;
import org.apache.uima.resource.metadata.ConfigurationParameter;
import org.apache.uima.resource.metadata.ConfigurationParameterDeclarations;
import org.apache.uima.resource.metadata.Import;
import org.apache.uima.resource.metadata.MetaDataObject;
import org.apache.uima.resource.metadata.OperationalProperties;
import org.apache.uima.resource.metadata.impl.Import_impl;
import org.apache.uima.resource.metadata.impl.PropertyXmlInfo;
import org.apache.uima.resource.metadata.impl.XmlizationInfo;
import org.apache.uima.util.InvalidXMLException;
import org.apache.uima.util.NameClassPair;
import org.apache.uima.util.XMLInputSource;
import org.apache.uima.util.XMLParser;
import org.apache.uima.util.XMLParser.ParsingOptions;
import org.w3c.dom.Element;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
/**
* Reference implementation of {@link AnalysisEngineDescription}. Note that this class contains two
* attributes of class Map, which are not supported by the default XML input/output routines.
* Therefore we override the {@link #writeAttributeAsElement(String,Class,Object,Writer)} and
* {@link #readAttributeFromXMLElement(String,Class,Element,XMLParser)} methods.
*
*
*/
public class AnalysisEngineDescription_impl extends ResourceCreationSpecifier_impl implements
AnalysisEngineDescription {
/**
* Name of the "delegateAnalysisEngineSpecifiers" property. Change this if interface changes.
*/
protected String PROP_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS = "delegateAnalysisEngineSpecifiers";
/**
* Name of the "delegateAnalysisEngineSpecifiersWithImports" property. Change this if interface
* changes.
*/
protected String PROP_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS_WITH_IMPORTS = "delegateAnalysisEngineSpecifiersWithImports";
/**
* Name of the "delegateAnalysisEngineSpecifiers" XML Element. Change this if schema changes.
*/
protected String ELEM_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS = "delegateAnalysisEngineSpecifiers";
private String mFrameworkImplementation;
private boolean mPrimitive;
private FlowControllerDeclaration mFlowControllerDeclaration;
private Map<String, ResourceSpecifier> mDelegateAnalysisEngineSpecifiers = new LinkedHashMap<String, ResourceSpecifier>();
private Map<String, MetaDataObject> mDelegateAnalysisEngineSpecifiersWithImports = new LinkedHashMap<String, MetaDataObject>();
private Map<String, Import> mProcessedImports = new HashMap<String, Import>();
private SofaMapping[] mSofaMappings;
static final long serialVersionUID = -8103625125291855592L;
/**
* Creates a new AnalysisEngineDescription_impl. Initializes the MetaData,
* DelegateAnalysisEngineSpecifiers, and ExternalResourcesRequired attributes.
*/
public AnalysisEngineDescription_impl() {
setMetaData(new AnalysisEngineMetaData_impl());
setFrameworkImplementation(Constants.JAVA_FRAMEWORK_NAME);
// Set default operational properties. These are used if the
// descriptor is constructed programatically, rather than parsed.
OperationalProperties opProps = UIMAFramework.getResourceSpecifierFactory()
.createOperationalProperties();
opProps.setModifiesCas(true);
opProps.setMultipleDeploymentAllowed(true);
opProps.setOutputsNewCASes(false);
getAnalysisEngineMetaData().setOperationalProperties(opProps);
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getFrameworkImplementation()
*/
public String getFrameworkImplementation() {
return mFrameworkImplementation;
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#setFrameworkImplementation(java.lang.String)
*/
public void setFrameworkImplementation(String aFrameworkImplementation) {
mFrameworkImplementation = aFrameworkImplementation;
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#isPrimitive()
*/
public boolean isPrimitive() {
return mPrimitive;
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#setPrimitive(boolean)
*/
public void setPrimitive(boolean aPrimitive) {
mPrimitive = aPrimitive;
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getAnnotatorImplementationName()
*/
public String getAnnotatorImplementationName() {
return getImplementationName();
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#setAnnotatorImplementationName(String)
*/
public void setAnnotatorImplementationName(String aImplementationName) {
setImplementationName(aImplementationName);
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getDelegateAnalysisEngineSpecifiers()
*/
public Map<String, ResourceSpecifier> getDelegateAnalysisEngineSpecifiers() throws InvalidXMLException {
resolveDelegateAnalysisEngineImports(UIMAFramework.newDefaultResourceManager(), false);
return Collections.unmodifiableMap(mDelegateAnalysisEngineSpecifiers);
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getDelegateAnalysisEngineSpecifiers()
*/
public Map<String, ResourceSpecifier> getDelegateAnalysisEngineSpecifiers(ResourceManager aResourceManager)
throws InvalidXMLException {
resolveDelegateAnalysisEngineImports(aResourceManager, false);
return Collections.unmodifiableMap(mDelegateAnalysisEngineSpecifiers);
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getDelegateAnalysisEngineSpecifiersWithImports()
*/
public Map<String, MetaDataObject> getDelegateAnalysisEngineSpecifiersWithImports() {
return mDelegateAnalysisEngineSpecifiersWithImports;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getFlowControllerDeclaration()
*/
public FlowControllerDeclaration getFlowControllerDeclaration() {
return mFlowControllerDeclaration;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#setFlowController(org.apache.uima.analysis_engine.metadata.FlowControllerDeclaration)
*/
public void setFlowControllerDeclaration(FlowControllerDeclaration aFlowControllerDeclaration) {
mFlowControllerDeclaration = aFlowControllerDeclaration;
}
public Map<String, ResourceSpecifier> getAllComponentSpecifiers(ResourceManager aResourceManager) throws InvalidXMLException {
if (aResourceManager == null) {
aResourceManager = UIMAFramework.newDefaultResourceManager();
}
resolveImports(aResourceManager);
Map<String, ResourceSpecifier> map = new LinkedHashMap<String, ResourceSpecifier>(mDelegateAnalysisEngineSpecifiers);
if (getFlowControllerDeclaration() != null) {
map.put(getFlowControllerDeclaration().getKey(), getFlowControllerDeclaration()
.getSpecifier());
}
return Collections.unmodifiableMap(map);
}
/**
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getAnalysisEngineMetaData()
*/
public AnalysisEngineMetaData getAnalysisEngineMetaData() {
return (AnalysisEngineMetaData) getMetaData();
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#getSofaMappings()
*/
public SofaMapping[] getSofaMappings() {
return mSofaMappings;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#setSofaMappings(org.apache.uima.analysis_engine.metadata.SofaMapping[])
*/
public void setSofaMappings(SofaMapping[] aSofaMappings) {
mSofaMappings = aSofaMappings;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#doFullValidation()
*/
public void doFullValidation() throws ResourceInitializationException {
// attempt to instantiate AE in "verification mode"
Map<String, Object> m = new HashMap<String, Object>();
m.put(AnalysisEngineImplBase.PARAM_VERIFICATION_MODE, Boolean.TRUE);
AnalysisEngine ae = UIMAFramework.produceAnalysisEngine(this, m);
validateSofaMappings();
ae.newCAS();
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#doFullValidation(org.apache.uima.resource.ResourceManager)
*/
public void doFullValidation(ResourceManager aResourceManager)
throws ResourceInitializationException {
// attempt to instantiate AE in "verification mode"
Map<String, Object> m = new HashMap<String, Object>();
m.put(AnalysisEngineImplBase.PARAM_VERIFICATION_MODE, Boolean.TRUE);
AnalysisEngine ae = UIMAFramework.produceAnalysisEngine(this, aResourceManager, m);
validateSofaMappings();
ae.newCAS();
}
/**
* Determines if the AnalysisEngineDescription is valid. An exception is thrown if it is not
* valid. This should be called from this Analysis Engine's initialize method. Note this does not
* check configuration parameter settings - that must be done by an explicit call to
* validateConfigurationParameterSettings.
*
* @param aResourceManager
* a ResourceManager instance to use to resolve imports by name.
*
* @throws ResourceInitializationException
* if <code>aDesc</code> is invalid
* @throws ResourceConfigurationException
* if the configuration parameter settings in <code>aDesc</code> are invalid
*/
public void validate(ResourceManager aResourceManager) throws ResourceInitializationException, ResourceConfigurationException {
// do validation common to all descriptor types (e.g. config parameters)
super.validate(aResourceManager);
// TypeSystem may not be specified for an Aggregate Analysis Engine
if (!isPrimitive() && getAnalysisEngineMetaData().getTypeSystem() != null) {
throw new ResourceInitializationException(
ResourceInitializationException.AGGREGATE_AE_TYPE_SYSTEM,
new Object[] { getSourceUrlString() });
}
//Keys in FixedFlow or LanguageCapabilityFlow must be defined
FlowConstraints fc = getAnalysisEngineMetaData().getFlowConstraints();
String[] keys = null;
if (fc instanceof FixedFlow) {
keys = ((FixedFlow)fc).getFixedFlow();
}
else if (fc instanceof CapabilityLanguageFlow) {
keys = ((CapabilityLanguageFlow)fc).getCapabilityLanguageFlow();
}
if (keys != null) {
for (int i = 0; i < keys.length; i++) {
if (!getDelegateAnalysisEngineSpecifiersWithImports().containsKey(keys[i])) {
throw new ResourceInitializationException(ResourceInitializationException.UNDEFINED_KEY_IN_FLOW,
new Object[]{getAnalysisEngineMetaData().getName(), keys[i], getSourceUrlString()});
}
}
}
}
/**
* Overrides{@link ResourceCreationSpecifier_impl#checkForInvalidParameterOverrides(ConfigurationParameter[], String)
* to validate parameter overrides in an aggregate AE. Also logs a warning for aggregate
* parameters with no declared overrides.
*
* @param aParams
* an array of ConfigurationParameters
* @param aGroupName
* name of groups in which these parameters are contained. Null if no group
* @param aResourceManager
* a ResourceManager instance to use to resolve imports by name.
*
* @throws ResourceInitializationException
* if there is an invalid parameter override declaration
*/
protected void checkForInvalidParameterOverrides(ConfigurationParameter[] aParams,
String aGroupName, ResourceManager aResourceManager) throws ResourceInitializationException {
//make sure delegate analysis engine specifiers are resolved using the correct resource manager
try {
resolveImports(aResourceManager);
} catch (InvalidXMLException e) {
throw new ResourceInitializationException(e);
}
for (int i = 0; i < aParams.length; i++) {
String[] overrides = aParams[i].getOverrides();
if (overrides.length > 0 && isPrimitive()) {
throw new ResourceInitializationException(
ResourceInitializationException.PARAM_OVERRIDE_IN_PRIMITIVE, new Object[] {
aParams[i].getName(), getMetaData().getName(), getSourceUrlString() });
} else if (overrides.length == 0 && !isPrimitive()) {
// Were deprecated for many years ... now no longer supported.
throw new ResourceInitializationException(
ResourceInitializationException.INVALID_PARAM_OVERRIDE_NO_OVERRIDES, new Object[] {
aParams[i].getName(), getMetaData().getName(), getSourceUrlString() });
}
for (int j = 0; j < overrides.length; j++) {
// overrides should be of form delegateKey/paramName
int slashPos = overrides[j].indexOf('/');
if (slashPos <= 0 || slashPos >= overrides[j].length()) {
throw new ResourceInitializationException(
ResourceInitializationException.INVALID_PARAM_OVERRIDE_SYNTAX, new Object[] {
overrides[j], aParams[i].getName(), getMetaData().getName(),
getSourceUrlString() });
}
String delegateKey = overrides[j].substring(0, slashPos);
String paramName = overrides[j].substring(slashPos + 1);
// get component descriptor (could be an AE or could be the FlowController)
ResourceSpecifier componentSpecifier = getComponentSpecifier(delegateKey);
if (componentSpecifier == null) {
throw new ResourceInitializationException(
ResourceInitializationException.INVALID_PARAM_OVERRIDE_NONEXISTENT_DELEGATE,
new Object[] { overrides[j], aParams[i].getName(), getMetaData().getName(),
delegateKey, getSourceUrlString() });
}
if (componentSpecifier instanceof ResourceCreationSpecifier) {
ConfigurationParameter overriddenParam = null;
ConfigurationParameterDeclarations delegateParamDecls = ((ResourceCreationSpecifier) componentSpecifier)
.getMetaData().getConfigurationParameterDeclarations();
if (aGroupName == null) // param not in group
{
overriddenParam = delegateParamDecls.getConfigurationParameter(null, paramName);
if (overriddenParam == null) {
throw new ResourceInitializationException(
ResourceInitializationException.INVALID_PARAM_OVERRIDE_NONEXISTENT_PARAMETER,
new Object[] { overrides[j], aParams[i].getName(), getMetaData().getName(),
delegateKey, paramName, getSourceUrlString() });
}
} else {
// make sure parameter exists in group
overriddenParam = delegateParamDecls.getConfigurationParameter(aGroupName, paramName);
if (overriddenParam == null) {
throw new ResourceInitializationException(
ResourceInitializationException.INVALID_PARAM_OVERRIDE_NONEXISTENT_PARAMETER_IN_GROUP,
new Object[] { overrides[j], aParams[i].getName(), getMetaData().getName(),
delegateKey, paramName, aGroupName, getSourceUrlString() });
}
}
}
}
}
}
/**
* Gets the ResourceSpecifier of one a component of this aggregate, based on its key. This may be
* the specifier of a component (i.e. delegate) AnalysisEngine, or it may be the specifier of the
* FlowController.
*
* @param key
* the key of the component specifier to get
* @return the specifier for the component, null if there is no component with the given key
* @throws ResourceInitializationException
* if there's a problem resolving imports
*/
public ResourceSpecifier getComponentSpecifier(String key) throws ResourceInitializationException {
ResourceSpecifier componentSpecifier;
if (getFlowControllerDeclaration() != null
&& key.equals(getFlowControllerDeclaration().getKey())) {
try {
getFlowControllerDeclaration().resolveImports();
} catch (InvalidXMLException e) {
throw new ResourceInitializationException(e);
}
componentSpecifier = getFlowControllerDeclaration().getSpecifier();
} else {
try {
componentSpecifier = (ResourceSpecifier) getDelegateAnalysisEngineSpecifiers().get(key);
} catch (InvalidXMLException e) {
throw new ResourceInitializationException(e);
}
}
return componentSpecifier;
}
/**
* Validate SofA mappings and inputs/outputs for an aggregate AE.
*
* @param aDesc
*/
protected void validateSofaMappings() throws ResourceInitializationException {
if (this.isPrimitive())
return;
String aggName = this.getAnalysisEngineMetaData().getName();
// build an actual Map (key: componentKey@/@componentSofa) from the sofa mappings
// along the way check that all component keys and component sofa names exist
Map<String, String> sofamap = new TreeMap<String, String>();
SofaMapping[] sofaMappings = this.getSofaMappings();
if (sofaMappings != null) {
for (int s = 0; s < sofaMappings.length; s++) {
String componentKey = sofaMappings[s].getComponentKey();
ResourceSpecifier componentSpec = getComponentSpecifier(componentKey);
if (componentSpec == null) {
throw new ResourceInitializationException(
ResourceInitializationException.SOFA_MAPPING_HAS_UNDEFINED_COMPONENT_KEY,
new Object[] { componentKey, sofaMappings[s].getAggregateSofaName(), aggName,
getSourceUrlString() });
}
String componentSofaName = sofaMappings[s].getComponentSofaName();
if (componentSofaName == null) {
componentSofaName = CAS.NAME_DEFAULT_SOFA;
} else if (componentSpec instanceof AnalysisEngineDescription
&& !CAS.NAME_DEFAULT_SOFA.equals(componentSofaName)
&& !declaresSofa((AnalysisEngineDescription) componentSpec, componentSofaName)) {
throw new ResourceInitializationException(
ResourceInitializationException.SOFA_MAPPING_HAS_UNDEFINED_COMPONENT_SOFA,
new Object[] { componentKey, componentSofaName,
sofaMappings[s].getAggregateSofaName(), aggName, getSourceUrlString() });
}
String compoundKey = sofaMappings[s].getComponentKey() + "@/@"
+ sofaMappings[s].getComponentSofaName();
String aggSofaName = sofaMappings[s].getAggregateSofaName();
// check for double-mapping
String existingMapping = (String) sofamap.get(compoundKey);
if (existingMapping != null && !existingMapping.equals(aggSofaName)) {
throw new ResourceInitializationException(
ResourceInitializationException.SOFA_MAPPING_CONFLICT, new Object[] {
sofaMappings[s].getComponentSofaName(), sofaMappings[s].getComponentKey(),
aggName, existingMapping, aggSofaName, getSourceUrlString() });
} else {
sofamap.put(compoundKey, aggSofaName);
}
}
}
// Rules for SofAs:
// (1) Each component output sofa must be mapped to an aggregate output sofa
// (2) Each aggregate output sofa must be mapped to a component output sofa
// (3) Each component input sofa must be mapped to an aggregate input sofa OR a component output
// sofa
// (4) Each aggregate input sofa must be mapped to a component input sofa
// From (1) and (3) we derive that:
// Each component input sofa must be mapped to an aggregate input sofa OR an aggregate output
// sofa
// (which is easier to check)
// Exception: if aggregate contains a remote component, we cannot check that remote
// component's input or output sofas, so rules (2) and (4) cannot be checked.
boolean containsRemote = false;
Set<String> correctlyMappedAggregateOutputs = new HashSet<String>();
Set<String> correctlyMappedAggregateInputs = new HashSet<String>();
Iterator<Map.Entry<String, ResourceSpecifier>> iter;
try {
iter = getDelegateAnalysisEngineSpecifiers().entrySet().iterator();
} catch (InvalidXMLException e) {
throw new ResourceInitializationException(e);
}
while (iter.hasNext()) {
Map.Entry<String, ResourceSpecifier> entry = iter.next();
String componentKey = entry.getKey();
ResourceSpecifier delegateSpec = entry.getValue();
if (delegateSpec instanceof AnalysisEngineDescription) {
Capability[] caps = ((AnalysisEngineDescription) delegateSpec).getAnalysisEngineMetaData()
.getCapabilities();
for (int i = 0; i < caps.length; i++) {
// all component output sofas must be mapped to aggregate output sofas
String[] outputSofas = caps[i].getOutputSofas();
for (int j = 0; j < outputSofas.length; j++) {
String aggSofa = (String) sofamap.get(componentKey + "@/@" + outputSofas[j]);
if (aggSofa == null) // no declared mapping, name remains unchanged
{
aggSofa = outputSofas[j];
}
if (!capabilitiesContainSofa(aggSofa, true)) {
throw new ResourceInitializationException(
ResourceInitializationException.OUTPUT_SOFA_NOT_DECLARED_IN_AGGREGATE,
new Object[] { outputSofas[j], componentKey, aggName, getSourceUrlString() });
}
correctlyMappedAggregateOutputs.add(aggSofa);
}
// all component input sofas must be mapped to aggregate input OR output sofas
String[] inputSofas = caps[i].getInputSofas();
for (int j = 0; j < inputSofas.length; j++) {
String aggSofa = (String) sofamap.get(componentKey + "@/@" + inputSofas[j]);
if (aggSofa == null) // no declared mapping, name remains unchanged
{
aggSofa = inputSofas[j];
}
if (!capabilitiesContainSofa(aggSofa, false) && !capabilitiesContainSofa(aggSofa, true)) {
throw new ResourceInitializationException(
ResourceInitializationException.INPUT_SOFA_HAS_NO_SOURCE, new Object[] {
inputSofas[j], componentKey, aggName, getSourceUrlString() });
}
correctlyMappedAggregateInputs.add(aggSofa);
}
// also check default text sofa
String aggDefSofa = (String) sofamap.get(componentKey + "@/@" + CAS.NAME_DEFAULT_SOFA);
if (aggDefSofa != null) {
if (capabilitiesContainSofa(aggDefSofa, true)) {
correctlyMappedAggregateOutputs.add(aggDefSofa);
} else {
correctlyMappedAggregateInputs.add(aggDefSofa);
}
}
}
} // delegateSpec is not an AnalysisEngineDescription
else {
containsRemote = true;
}
}
if (!containsRemote) {
// check that all aggregate outputs and inputs were mapped correclty to
// component inputs/outputs
Capability[] caps = this.getAnalysisEngineMetaData().getCapabilities();
for (int i = 0; i < caps.length; i++) {
String[] sofas = caps[i].getOutputSofas();
for (int j = 0; j < sofas.length; j++) {
if (!correctlyMappedAggregateOutputs.contains(sofas[j])) {
throw new ResourceInitializationException(
ResourceInitializationException.AGGREGATE_SOFA_NOT_MAPPED, new Object[] {
sofas[j], aggName, getSourceUrlString() });
}
}
sofas = caps[i].getInputSofas();
for (int j = 0; j < sofas.length; j++) {
if (!correctlyMappedAggregateInputs.contains(sofas[j])) {
throw new ResourceInitializationException(
ResourceInitializationException.AGGREGATE_SOFA_NOT_MAPPED, new Object[] {
sofas[j], aggName, getSourceUrlString() });
}
}
}
}
}
private boolean declaresSofa(AnalysisEngineDescription aDesc, String aSofaName) {
Capability[] caps = aDesc.getAnalysisEngineMetaData().getCapabilities();
for (int i = 0; i < caps.length; i++) {
String[] sofas = caps[i].getOutputSofas();
for (int j = 0; j < sofas.length; j++) {
if (aSofaName.equals(sofas[j])) {
return true;
}
}
sofas = caps[i].getInputSofas();
for (int j = 0; j < sofas.length; j++) {
if (aSofaName.equals(sofas[j])) {
return true;
}
}
}
return false;
}
protected boolean capabilitiesContainSofa(String aSofaName, boolean aOutput) {
Capability[] caps = this.getAnalysisEngineMetaData().getCapabilities();
for (int i = 0; i < caps.length; i++) {
String[] sofas = aOutput ? caps[i].getOutputSofas() : caps[i].getInputSofas();
for (int j = 0; j < sofas.length; j++) {
if (aSofaName.equals(sofas[j])) {
return true;
}
}
}
return false;
}
/**
* Overridden to add Delegate AE Specifiers to the result list. Default introspection
* implementation won't return it because it has no set method. We've also overridden the XML
* import/export methods, though, so that set methods are not required.
*
* @see org.apache.uima.resource.MetaDataObject#listAttributes()
*/
public List<NameClassPair> listAttributes() {
List<NameClassPair> result = super.listAttributes();
result.add(new NameClassPair(PROP_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS_WITH_IMPORTS, Map.class
.getName()));
return result;
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#toXML(java.io.OutputStream,
* boolean)
*/
public void toXML(OutputStream aOutputStream, boolean aPreserveDelegateAnalysisEngineImports)
throws SAXException, IOException {
if (aPreserveDelegateAnalysisEngineImports) {
// trick the writePropertyAsElement method into thinking that
// imports haven't been resolved yet
Map<String, ResourceSpecifier> tempMap = mDelegateAnalysisEngineSpecifiers;
mDelegateAnalysisEngineSpecifiers = Collections.emptyMap();
toXML(aOutputStream);
mDelegateAnalysisEngineSpecifiers = tempMap;
} else {
toXML(aOutputStream);
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#toXML(java.io.Writer, boolean)
*/
public void toXML(Writer aWriter, boolean aPreserveDelegateAnalysisEngineImports)
throws SAXException, IOException {
if (aPreserveDelegateAnalysisEngineImports) {
// trick the writePropertyAsElement method into thinking that
// imports haven't been resolved yet
Map<String, ResourceSpecifier> tempMap = mDelegateAnalysisEngineSpecifiers;
mDelegateAnalysisEngineSpecifiers = Collections.emptyMap();
toXML(aWriter);
mDelegateAnalysisEngineSpecifiers = tempMap;
} else {
toXML(aWriter);
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#toXML(org.xml.sax.ContentHandler,
* boolean, boolean)
*/
public void toXML(ContentHandler aContentHandler, boolean aWriteDefaultNamespaceAttribute,
boolean aPreserveDelegateAnalysisEngineImports) throws SAXException {
if (aPreserveDelegateAnalysisEngineImports) {
// trick the writePropertyAsElement method into thinking that
// imports haven't been resolved yet
Map<String, ResourceSpecifier> tempMap = mDelegateAnalysisEngineSpecifiers;
mDelegateAnalysisEngineSpecifiers = Collections.emptyMap();
toXML(aContentHandler, aWriteDefaultNamespaceAttribute);
mDelegateAnalysisEngineSpecifiers = tempMap;
} else {
toXML(aContentHandler, aWriteDefaultNamespaceAttribute);
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#resolveImports(org.apache.uima.resource.ResourceManager)
*/
public void resolveImports(ResourceManager aResourceManager) throws InvalidXMLException {
resolveImports(new HashSet<String>(), aResourceManager);
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.analysis_engine.AnalysisEngineDescription#resolveImports(java.util.Collection,
* org.apache.uima.resource.ResourceManager)
*/
public void resolveImports(Collection<String> aAlreadyImportedDelegateAeUrls,
ResourceManager aResourceManager) throws InvalidXMLException {
// add our own URL, if known, to the collection of already imported URLs
if (getSourceUrl() != null) {
aAlreadyImportedDelegateAeUrls.add(getSourceUrl().toString());
}
// resolve delegate AE imports (and recursively resolve imports therein)
resolveDelegateAnalysisEngineImports(aAlreadyImportedDelegateAeUrls, aResourceManager, true);
// resolve flow controller import
if (getFlowControllerDeclaration() != null) {
getFlowControllerDeclaration().resolveImports(aResourceManager);
}
// resolve imports in metadata (type systems, indexes, type priorities)
if (getAnalysisEngineMetaData() != null) {
getAnalysisEngineMetaData().resolveImports(aResourceManager);
}
// resolve imports in resource manager configuration
if (getResourceManagerConfiguration() != null) {
getResourceManagerConfiguration().resolveImports(aResourceManager);
}
}
/**
* Resolves imports of delegate Analysis Engines. This reads from the
* delegateAnalysisEngineSpecifiersWithImports map and populates the
* delegateAnalysisEngineSpecifiers map.
*
* @param aRecursive If true, this method will call {@link #resolveImports(Collection, ResourceManager)}
* on each delegate. If a cirular import is found, an exception will be thrown.
*/
protected void resolveDelegateAnalysisEngineImports(ResourceManager aResourceManager, boolean aRecursive)
throws InvalidXMLException {
// add our own URL, if known, to the collection of enclosing aggregate URLs
Set<String> urls = new HashSet<String>();
if (getSourceUrl() != null) {
urls.add(getSourceUrl().toString());
}
resolveDelegateAnalysisEngineImports(urls, aResourceManager, aRecursive);
}
/**
* Resolves imports of delegate Analysis Engines. This reads from the
* delegateAnalysisEngineSpecifiersWithImports map and populates the
* delegateAnalysisEngineSpecifiers map.
*
* @param aEnclosingAggregateAeUrls URLs of enclosing aggregate AEs. Used to detect circular imports.
* @param aRecursive If true, this method will call {@link #resolveImports(Collection, ResourceManager)}
* on each delegate. If a circular import is found, an exception will be thrown.
*/
protected void resolveDelegateAnalysisEngineImports(Collection<String> aEnclosingAggregateAeUrls,
ResourceManager aResourceManager, boolean aRecursive) throws InvalidXMLException {
Set<String> keys = new HashSet<String>(); // keep track of keys we've encountered
// so we can remove stale entries
for (Map.Entry<String, MetaDataObject> entry :
getDelegateAnalysisEngineSpecifiersWithImports().entrySet()) {
String key = entry.getKey();
keys.add(key);
if (entry.getValue() instanceof Import) {
Import aeImport = ((Import) entry.getValue());
// see if we processed this already
if (entry.getValue().equals(mProcessedImports.get(key))) {
continue;
}
// make sure Import's relative path base is set, to allow for
// users who create
// new import objects
if (aeImport instanceof Import_impl) {
((Import_impl) aeImport).setSourceUrlIfNull(this.getSourceUrl());
}
// locate import target
URL url = aeImport.findAbsoluteUrl(aResourceManager);
// check for resursive import
if (aEnclosingAggregateAeUrls.contains(url.toString())) {
String name = getMetaData() == null ? "<null>" : getMetaData().getName();
throw new InvalidXMLException(InvalidXMLException.CIRCULAR_AE_IMPORT, new Object[] {
name, url });
}
// parse import target
XMLInputSource input;
try {
input = new XMLInputSource(url);
} catch (IOException e) {
throw new InvalidXMLException(InvalidXMLException.IMPORT_FAILED_COULD_NOT_READ_FROM_URL,
new Object[] { url, aeImport.getSourceUrlString() }, e);
}
ResourceSpecifier spec = UIMAFramework.getXMLParser().parseResourceSpecifier(input);
// update entry in derived mDelegateAnalysisEngineSpecifiers map.
mDelegateAnalysisEngineSpecifiers.put(key, spec);
// add to processed imports map so we don't redo
mProcessedImports.put(key, aeImport);
// now resolve imports in ths delegate
if (spec instanceof AnalysisEngineDescription) {
Set<String> alreadyImportedUrls = new HashSet<String>(aEnclosingAggregateAeUrls);
alreadyImportedUrls.add(url.toString());
((AnalysisEngineDescription) spec).resolveImports(alreadyImportedUrls, aResourceManager);
}
} else {
// not an import -- copy directly to derived mDelegateAnalysisEngineSpecifiers map.
mDelegateAnalysisEngineSpecifiers.put(entry.getKey(), (ResourceSpecifier) entry.getValue());
// resolve imports recursively on the delegate
if (entry.getValue() instanceof AnalysisEngineDescription) {
((AnalysisEngineDescription) entry.getValue()).resolveImports(
aEnclosingAggregateAeUrls, aResourceManager);
}
}
}
// remove stale entries
List<String> staleKeys = new ArrayList<String>();
for (Map.Entry<String, ResourceSpecifier> entry : mDelegateAnalysisEngineSpecifiers.entrySet()) {
String key = entry.getKey();
if (!keys.contains(key)) {
staleKeys.add(key);
}
}
for (String key : staleKeys) {
mDelegateAnalysisEngineSpecifiers.remove(key);
mProcessedImports.remove(key);
}
}
/**
* Overridden to handle XML export of the DelegateAnalysisEngineSpecifiers attribute. This
* attribute has a value of type <code>Map</code>, which is not handled by the default XML
* export logic.
*
* @see org.apache.uima.MetaDataObject_impl#writePropertyAsElement(PropertyXmlInfo,String,ContentHandler)
*/
protected void writePropertyAsElement(PropertyXmlInfo aPropInfo, String aNamespace,
ContentHandler aContentHandler) throws SAXException {
if (PROP_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS_WITH_IMPORTS.equals(aPropInfo.propertyName)) {
// special logic here -- if imports have been resolved, then we want
// to write
// out the XML with those resolved imports. If imports have not been
// resolved,
// (mDelegateAnalysisEngineSpecifiers is empty), then we want to
// write out
// the original XML, which has the import declarations.
String propName = PROP_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS;
if (mDelegateAnalysisEngineSpecifiers.isEmpty()) {
propName = PROP_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS_WITH_IMPORTS;
}
writeMapPropertyToXml(propName, ELEM_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS, "key",
"delegateAnalysisEngine", aPropInfo.omitIfNull, aNamespace, aContentHandler);
} else {
// for all other attributes, use the default superclass behavior
super.writePropertyAsElement(aPropInfo, aNamespace, aContentHandler);
}
}
/**
* Overridden to handle XML import of the DelegateAnalysisEngineSpecifiers attribute. This
* attribute has a value of type <code>Map</code>, which is not handled by the default XML
* import logic.
*
* @see org.apache.uima.resource.impl.MetaDataObject_impl#readPropertyValueFromXMLElement(org.apache.uima.resource.impl.PropertyXmlInfo,
* org.w3c.dom.Element, org.apache.uima.util.XMLParser)
*/
protected void readPropertyValueFromXMLElement(PropertyXmlInfo aPropXmlInfo, Element aElement,
XMLParser aParser, XMLParser.ParsingOptions aOptions) throws InvalidXMLException {
String propName = aPropXmlInfo.propertyName;
if (PROP_DELEGATE_ANALYSIS_ENGINE_SPECIFIERS_WITH_IMPORTS.equals(propName)) {
readMapPropertyFromXml(propName, aElement, "key", "delegateAnalysisEngine", aParser,
aOptions, false);
} else {
// for all other attributes, use the default superclass behavior
super.readPropertyValueFromXMLElement(aPropXmlInfo, aElement, aParser, aOptions);
}
}
/**
* Overridden to set default operational properties if they are not specified in descriptor.
*/
public void buildFromXMLElement(Element aElement, XMLParser aParser, ParsingOptions aOptions)
throws InvalidXMLException {
super.buildFromXMLElement(aElement, aParser, aOptions);
if (getAnalysisEngineMetaData().getOperationalProperties() == null) {
OperationalProperties opProps = UIMAFramework.getResourceSpecifierFactory()
.createOperationalProperties();
opProps.setModifiesCas(true);
opProps.setMultipleDeploymentAllowed(true);
getAnalysisEngineMetaData().setOperationalProperties(opProps);
}
}
protected XmlizationInfo getXmlizationInfo() {
return XMLIZATION_INFO;
}
/**
* Static method to get XmlizationInfo, used by subclasses to set up their own XmlizationInfo.
*/
protected static XmlizationInfo getXmlizationInfoForClass() {
return XMLIZATION_INFO;
}
static final private XmlizationInfo XMLIZATION_INFO = new XmlizationInfo(
"analysisEngineDescription", new PropertyXmlInfo[] {
new PropertyXmlInfo("frameworkImplementation"),
new PropertyXmlInfo("primitive"),
new PropertyXmlInfo("annotatorImplementationName"),
new PropertyXmlInfo("delegateAnalysisEngineSpecifiersWithImports",
"delegateAnalysisEngineSpecifiers"), // NOTE: custom
// XMLization
new PropertyXmlInfo("flowControllerDeclaration", null),
new PropertyXmlInfo("metaData", null),
new PropertyXmlInfo("externalResourceDependencies"),
new PropertyXmlInfo("resourceManagerConfiguration", null),
new PropertyXmlInfo("sofaMappings") });
}