| /* |
| * 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.flow.impl; |
| |
| import java.io.IOException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.apache.uima.UIMAFramework; |
| import org.apache.uima.UIMARuntimeException; |
| import org.apache.uima.analysis_engine.AnalysisEngineProcessException; |
| import org.apache.uima.analysis_engine.ResultSpecification; |
| import org.apache.uima.analysis_engine.TypeOrFeature; |
| import org.apache.uima.analysis_engine.metadata.AnalysisEngineMetaData; |
| import org.apache.uima.analysis_engine.metadata.CapabilityLanguageFlow; |
| import org.apache.uima.cas.CAS; |
| import org.apache.uima.cas.text.Language; |
| import org.apache.uima.flow.CasFlowController_ImplBase; |
| import org.apache.uima.flow.Flow; |
| import org.apache.uima.flow.FlowControllerContext; |
| import org.apache.uima.flow.FlowControllerDescription; |
| import org.apache.uima.resource.ResourceInitializationException; |
| import org.apache.uima.resource.metadata.Capability; |
| import org.apache.uima.util.InvalidXMLException; |
| import org.apache.uima.util.XMLInputSource; |
| |
| /** |
| * FlowController for the CapabilityLanguageFlow, which uses a linear flow but may skip some of the |
| * AEs in the flow if they do not handle the language of the current document or if their outputs |
| * have already been produced by a previous AE in the flow. |
| */ |
| public class CapabilityLanguageFlowController extends CasFlowController_ImplBase { |
| private List<AnalysisSequenceCapabilityNode> mStaticSequence; |
| |
| private Map<String, AnalysisEngineMetaData> mComponentMetaDataMap; |
| |
| private Map<String, List<AnalysisSequenceCapabilityNode>> mFlowTable; |
| |
| private final Map<String, ResultSpecification> lastResultSpecForComponent = |
| new HashMap<String, ResultSpecification>(); |
| |
| /** |
| * main language separator e.g 'en' and 'en-US' |
| */ |
| private static final char LANGUAGE_SEPARATOR = '-'; |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.uima.flow.FlowController#initialize(FlowControllerContext) |
| */ |
| public void initialize(FlowControllerContext aContext) throws ResourceInitializationException { |
| super.initialize(aContext); |
| mComponentMetaDataMap = (Map<String, AnalysisEngineMetaData>)aContext.getAnalysisEngineMetaDataMap(); |
| |
| // build a list of AnalysisSequenceNodes from the capabilityLanguageFlow |
| mStaticSequence = new ArrayList<AnalysisSequenceCapabilityNode>(); |
| CapabilityLanguageFlow flowConstraints = (CapabilityLanguageFlow) aContext |
| .getAggregateMetadata().getFlowConstraints(); |
| for (String aeKey : flowConstraints.getCapabilityLanguageFlow()) { |
| mStaticSequence.add( |
| new AnalysisSequenceCapabilityNode( |
| aeKey, |
| mComponentMetaDataMap.get(aeKey).getCapabilities(), |
| null)); |
| } |
| |
| // compute flow table with the specified capabilities |
| mFlowTable = computeFlowTable(aContext.getAggregateMetadata().getCapabilities()); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.uima.flow.CasFlowController_ImplBase#computeFlow(org.apache.uima.cas.CAS) |
| */ |
| public Flow computeFlow(CAS aCAS) throws AnalysisEngineProcessException { |
| CapabilityLanguageFlowObject flow = new CapabilityLanguageFlowObject(mFlowTable, this); |
| flow.setCas(aCAS); |
| return flow; |
| } |
| |
| /** |
| * method computeFlowTable create the flow table for faster processing. The flow table includes |
| * the corresponding flow sequence for all languages in the capabilities |
| * |
| * @param aCapabilities |
| * aggregate engine capabilities |
| * @return Map - flow table includes all sequences for all languages |
| */ |
| protected Map<String, List<AnalysisSequenceCapabilityNode>> computeFlowTable(Capability[] aCapabilities) { |
| // create flowTable |
| Map<String, List<AnalysisSequenceCapabilityNode>> flowTable = |
| new HashMap<String, List<AnalysisSequenceCapabilityNode>>(); |
| |
| // get all languages from the capabilities |
| Set<String> languages = new HashSet<String>(); |
| for (Capability capability : aCapabilities) { |
| for (String capabilityLanguage : capability.getLanguagesSupported()) { |
| languages.add(capabilityLanguage); |
| } |
| } |
| |
| // create flow table with sequences for all languages |
| for (String capabilityLanguage : languages) { |
| flowTable.put(capabilityLanguage, computeSequence(capabilityLanguage, aCapabilities)); |
| } |
| |
| return flowTable; |
| } |
| |
| /** |
| * method computeSequence creates a capabilityLanguageAnalysisSequence for the given language |
| * |
| * @param language |
| * current language |
| * @param aCapabilities |
| * output capabilities of the aggregate engine |
| * |
| * @return List - capabilityLanguageAnalysisSequence for the current language |
| */ |
| protected List<AnalysisSequenceCapabilityNode> computeSequence(String language, Capability[] aCapabilities) { |
| language = Language.normalize(language); // lower-cases, replaces _ with -, changes null to x-unspecified |
| |
| // create resultSpec from the current aggregate capabilities |
| ResultSpecification aggrResultsToProduce = UIMAFramework.getResourceSpecifierFactory() |
| .createResultSpecification(); |
| |
| if (aCapabilities != null) { |
| aggrResultsToProduce.addCapabilities(aCapabilities); |
| } else { |
| return null; |
| } |
| |
| // create array list for the current sequence |
| List<AnalysisSequenceCapabilityNode> newSequence = new ArrayList<AnalysisSequenceCapabilityNode>(); |
| |
| // loop over all annotators that should be called |
| // In this loop we will gradually reduce the set of output capabilities |
| for (int sequenceIndex = 0; sequenceIndex < mStaticSequence.size(); sequenceIndex++) { |
| // get array of output capabilities for the current language from the current result spec |
| TypeOrFeature[] tofsNeeded = aggrResultsToProduce.getResultTypesAndFeatures(language); |
| |
| // Augment these outputCapabilities if the language-spec is for a country, to |
| // include the outputCapabilities for the language without the country-spec. |
| |
| // strip language extension if available |
| int index = language.indexOf(LANGUAGE_SEPARATOR); |
| |
| // if country extension is available |
| if (index >= 0) { |
| // create Set for outputSpecs, so we can eliminate duplicates |
| Set<TypeOrFeature> outputSpec = new HashSet<TypeOrFeature>(); |
| |
| // add language with country extension removed, |
| // to the existing output capabilities (or if non exist, just use |
| // the capabilities for the language without the country extension) |
| if (tofsNeeded.length > 0) { |
| // copy all existing capabilities to the Set |
| for (TypeOrFeature outputCapability : tofsNeeded) { |
| outputSpec.add(outputCapability); |
| } |
| |
| // get array of output capabilities only for the language without country extension |
| tofsNeeded = aggrResultsToProduce.getResultTypesAndFeatures(language.substring(0, index)); |
| |
| // add language output capabilities to the Set |
| for (TypeOrFeature outputCapability : tofsNeeded) { |
| outputSpec.add(outputCapability); |
| } |
| |
| // convert all output capabilities to a outputCapabilities array |
| tofsNeeded = new TypeOrFeature[outputSpec.size()]; |
| outputSpec.toArray(tofsNeeded); |
| } else { // for language with country extension was noting found |
| // get array of output capabilities with the new main language without country extension |
| tofsNeeded = aggrResultsToProduce.getResultTypesAndFeatures(language.substring(0, index)); |
| } |
| } |
| |
| // current analysis node which contains the current analysis engine |
| AnalysisSequenceCapabilityNode node; |
| |
| // result spec for the current analysis engine |
| ResultSpecification currentAnalysisResultSpec = null; |
| |
| // flag if current analysis engine should be called or not |
| boolean shouldEngineBeCalled = false; |
| |
| // check output capabilities from the current result spec |
| |
| // get next analysis engine from the sequence node |
| node = mStaticSequence.get(sequenceIndex); |
| |
| // get capability container from the current analysis engine |
| ResultSpecification delegateProduces = node.getCapabilityContainer(); |
| |
| // create current analysis result spec without any language information |
| currentAnalysisResultSpec = UIMAFramework.getResourceSpecifierFactory() |
| .createResultSpecification(); |
| |
| // check if engine should be called - |
| // loop over all remaining output capabilities of the aggregate's result spec |
| // to see if this component of the aggregate produces that type or feature, |
| // for this language |
| for (TypeOrFeature tof : tofsNeeded) { |
| if ((tof.isType() && delegateProduces.containsType(tof.getName(), language)) || |
| (!tof.isType() && delegateProduces.containsFeature(tof.getName(), language))) { |
| // if (capabilityContainer.hasOutputTypeOrFeature(tof, language, true)) { |
| currentAnalysisResultSpec.addResultTypeOrFeature(tof); |
| shouldEngineBeCalled = true; |
| // remove current ToF from the result spec |
| aggrResultsToProduce.removeTypeOrFeature(tof); |
| } |
| } |
| |
| // skip engine if not output capability match |
| |
| // should be called is false if this engine produces none of the |
| // needed outputs of the aggregate |
| if (shouldEngineBeCalled == true) { |
| // tell this component which output types/features need to be produced |
| // note: As an exception to the way normal result-specifications are produced, |
| // here we *don't* add the types/features which are input to |
| // other delegates need to be produced. |
| // This is for backward compatibility. |
| node.setResultSpec(currentAnalysisResultSpec); |
| |
| // add note to the current sequence |
| newSequence.add((AnalysisSequenceCapabilityNode)node.clone()); |
| } else { |
| // engine should not be called, but add null to the sequence to track that |
| // engine should not be called |
| newSequence.add(null); |
| } |
| } // loop over all delegates in the flow sequence |
| |
| return newSequence; |
| } |
| |
| public static FlowControllerDescription getDescription() { |
| URL descUrl = FixedFlowController.class |
| .getResource("/org/apache/uima/flow/CapabilityLanguageFlowController.xml"); |
| FlowControllerDescription desc; |
| try { |
| desc = (FlowControllerDescription) UIMAFramework.getXMLParser().parse( |
| new XMLInputSource(descUrl)); |
| } catch (InvalidXMLException e) { |
| throw new UIMARuntimeException(e); |
| } catch (IOException e) { |
| throw new UIMARuntimeException(e); |
| } |
| return desc; |
| } |
| |
| public Map<String, ResultSpecification> getLastResultSpecForComponent() { |
| return lastResultSpecForComponent; |
| } |
| } |
