| /* |
| * 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.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.Vector; |
| |
| import org.apache.uima.analysis_engine.ResultSpecification; |
| import org.apache.uima.analysis_engine.TypeOrFeature; |
| import org.apache.uima.cas.Feature; |
| import org.apache.uima.cas.Type; |
| import org.apache.uima.cas.TypeSystem; |
| import org.apache.uima.resource.metadata.Capability; |
| 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; |
| |
| /** |
| * Reference implementaion of {@link ResultSpecification}. |
| * |
| * |
| */ |
| public final class ResultSpecification_impl extends MetaDataObject_impl implements |
| ResultSpecification { |
| |
| private static final long serialVersionUID = 8516517600467270594L; |
| |
| static final String UNSPECIFIED_LANGUAGE = "x-unspecified"; |
| |
| /** |
| * main language separator e.g 'en' and 'en-US' |
| */ |
| private static final char LANGUAGE_SEPARATOR = '-'; |
| |
| /** |
| * Map from TypeOrFeature objects to HashSets that include the language codes (Strings) for which |
| * that type or feature should be produced. |
| */ |
| private Map mTypesAndFeatures = new HashMap(); |
| |
| /** |
| * Map from String type or feature names to HashSets that include the language codes (Strings) for |
| * which that type or feature should be produced. This is populated by the compile() method, and |
| * includes subtypes as well as the individual feature names for types that have |
| * allAnnotatorFeatures=true. |
| */ |
| private Map mCompiledNameToLanguageMap = new HashMap(); |
| |
| /** |
| * Default language set to use if nothing else is specified |
| */ |
| private HashSet mDefaultLanguage = new HashSet(); |
| |
| /** |
| * constructor init the default languge set with the language x-unspecified |
| */ |
| public ResultSpecification_impl() { |
| mDefaultLanguage.add(UNSPECIFIED_LANGUAGE); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#getResultTypesAndFeatures() |
| */ |
| public TypeOrFeature[] getResultTypesAndFeatures() { |
| TypeOrFeature[] arr = new TypeOrFeature[mTypesAndFeatures.size()]; |
| mTypesAndFeatures.keySet().toArray(arr); |
| return arr; |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#getResultTypesAndFeatures(java.lang.String) |
| */ |
| public TypeOrFeature[] getResultTypesAndFeatures(String language) { |
| // get language without country if applicable |
| String baseLanguage = null; |
| int index = language.indexOf(LANGUAGE_SEPARATOR); |
| if (index > -1) { |
| baseLanguage = language.substring(0, index); |
| } |
| |
| // holds the found ToFs for the specified language |
| Vector vec = new Vector(); |
| |
| Iterator it = mTypesAndFeatures.keySet().iterator(); |
| while (it.hasNext()) { |
| // get current key |
| TypeOrFeature tof = (TypeOrFeature) it.next(); |
| // get value for the current key |
| Set values = (HashSet) mTypesAndFeatures.get(tof); |
| if (values.contains(language) || values.contains(UNSPECIFIED_LANGUAGE) |
| || values.contains(baseLanguage)) { |
| // add tof to the TypeOfFeature array |
| vec.add(tof); |
| } |
| } |
| |
| // create array for return |
| TypeOrFeature[] arr = new TypeOrFeature[vec.size()]; |
| |
| // convert vector to TypeOrFeature[] |
| vec.toArray(arr); |
| |
| return arr; |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#setResultTypesAndFeatures(org.apache.uima.analysis_engine.TypeOrFeature[]) |
| */ |
| public void setResultTypesAndFeatures(TypeOrFeature[] aTypesAndFeatures) { |
| mTypesAndFeatures.clear(); |
| for (int i = 0; i < aTypesAndFeatures.length; i++) { |
| mTypesAndFeatures.put(aTypesAndFeatures[i], mDefaultLanguage); |
| } |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#setResultTypesAndFeatures(org.apache.uima.analysis_engine.TypeOrFeature[], |
| * java.lang.String[]) |
| */ |
| public void setResultTypesAndFeatures(TypeOrFeature[] aTypesAndFeatures, String[] aLanguageIDs) { |
| if (aLanguageIDs != null) { |
| // create HashSet for the aLanguageIDs with the initial capacity of the aLanguageIDs size |
| HashSet languagesSupported = new HashSet(aLanguageIDs.length); |
| // add all supported languages to at HashSet |
| for (int x = 0; x < aLanguageIDs.length; x++) { |
| // add current language to the HashSet |
| languagesSupported.add(aLanguageIDs[x]); |
| } |
| |
| mTypesAndFeatures.clear(); |
| for (int i = 0; i < aTypesAndFeatures.length; i++) { |
| mTypesAndFeatures.put(aTypesAndFeatures[i], languagesSupported); |
| } |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } else { |
| // if aLangugeIDs is null set ToFs for the default language |
| setResultTypesAndFeatures(aTypesAndFeatures); |
| } |
| |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addResultTypeOrFeature(org.apache.uima.analysis_engine.TypeOrFeature) |
| */ |
| public void addResultTypeOrFeature(TypeOrFeature aTypeOrFeature) { |
| mTypesAndFeatures.put(aTypeOrFeature, mDefaultLanguage); |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addResultTypeOrFeature(org.apache.uima.analysis_engine.TypeOrFeature, |
| * java.lang.String[]) |
| */ |
| public void addResultTypeOrFeature(TypeOrFeature aTypeOrFeature, String[] aLanguageIDs) { |
| if (aLanguageIDs != null) { |
| // create HashSet for the aLanguageIDs with the initial capacity of the aLanguageIDs size |
| HashSet languagesSupported = new HashSet(aLanguageIDs.length); |
| // add all supported languages to at HashSet |
| for (int x = 0; x < aLanguageIDs.length; x++) { |
| // add current language to the HashSet |
| languagesSupported.add(aLanguageIDs[x]); |
| } |
| |
| mTypesAndFeatures.put(aTypeOrFeature, languagesSupported); |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } else { |
| // if aLangugeIDs is null add ToF with the default language |
| addResultTypeOrFeature(aTypeOrFeature); |
| } |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addResultType(java.lang.String, |
| * boolean) |
| */ |
| public void addResultType(String aTypeName, boolean aAllAnnotatorFeatures) { |
| TypeOrFeature t = new TypeOrFeature_impl(); |
| t.setType(true); |
| t.setName(aTypeName); |
| t.setAllAnnotatorFeatures(aAllAnnotatorFeatures); |
| mTypesAndFeatures.put(t, mDefaultLanguage); |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addResultType(java.lang.String, |
| * boolean, java.lang.String[]) |
| */ |
| public void addResultType(String aTypeName, boolean aAllAnnotatorFeatures, String[] aLanguageIDs) { |
| if (aLanguageIDs != null) { |
| // create HashSet for the aLanguageIDs with the initial capacity of the aLanguageIDs size |
| HashSet languagesSupported = new HashSet(aLanguageIDs.length); |
| // add all supported languages to at HashSet |
| for (int x = 0; x < aLanguageIDs.length; x++) { |
| // add current language to the HashSet |
| languagesSupported.add(aLanguageIDs[x]); |
| } |
| |
| TypeOrFeature t = new TypeOrFeature_impl(); |
| t.setType(true); |
| t.setName(aTypeName); |
| t.setAllAnnotatorFeatures(aAllAnnotatorFeatures); |
| HashSet existingLanguages = (HashSet) mTypesAndFeatures.get(t); |
| if (existingLanguages != null) { |
| existingLanguages.addAll(languagesSupported); |
| } else { |
| mTypesAndFeatures.put(t, languagesSupported); |
| } |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } else { |
| // if aLangugeIDs is null add type with the default language |
| addResultType(aTypeName, aAllAnnotatorFeatures); |
| } |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addResultFeature(java.lang.String) |
| */ |
| public void addResultFeature(String aFullFeatureName) { |
| TypeOrFeature f = new TypeOrFeature_impl(); |
| f.setType(false); |
| f.setName(aFullFeatureName); |
| mTypesAndFeatures.put(f, mDefaultLanguage); |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addResultFeature(java.lang.String, |
| * java.lang.String[]) |
| */ |
| public void addResultFeature(String aFullFeatureName, String[] aLanguageIDs) { |
| if (aLanguageIDs != null) { |
| // create HashSet for the aLanguageIDs with the initial capacity of the aLanguageIDs size |
| HashSet languagesSupported = new HashSet(aLanguageIDs.length); |
| // add all supported languages to at HashSet |
| for (int x = 0; x < aLanguageIDs.length; x++) { |
| // add current language to the HashSet |
| languagesSupported.add(aLanguageIDs[x]); |
| } |
| |
| TypeOrFeature f = new TypeOrFeature_impl(); |
| f.setType(false); |
| f.setName(aFullFeatureName); |
| HashSet existingLanguages = (HashSet) mTypesAndFeatures.get(f); |
| if (existingLanguages != null) { |
| existingLanguages.addAll(languagesSupported); |
| } else { |
| mTypesAndFeatures.put(f, languagesSupported); |
| } |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } else { |
| // if aLangugeIDs is null add type with the default language |
| addResultFeature(aFullFeatureName); |
| } |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#compile(org.apache.uima.cas.TypeSystem) |
| */ |
| public void compile(TypeSystem aTypeSystem) { |
| mCompiledNameToLanguageMap.clear(); |
| Iterator it = mTypesAndFeatures.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry elem = (Map.Entry) it.next(); |
| TypeOrFeature tof = (TypeOrFeature) elem.getKey(); |
| if (tof.isType()) { |
| Type t = aTypeSystem.getType(tof.getName()); |
| if (t != null) { |
| addTypeRecursive(t, aTypeSystem, (HashSet) elem.getValue(), tof.isAllAnnotatorFeatures()); |
| } |
| } else // feature |
| { |
| mCompiledNameToLanguageMap.put(tof.getName(), elem.getValue()); |
| } |
| } |
| // TODO: process the set of intersections |
| } |
| |
| /** |
| * @param t |
| */ |
| private void addTypeRecursive(Type type, TypeSystem typeSystem, HashSet languages, |
| boolean allFeatures) { |
| mCompiledNameToLanguageMap.put(type.getName(), languages); |
| if (allFeatures) { |
| List features = type.getFeatures(); |
| Iterator featIt = features.iterator(); |
| while (featIt.hasNext()) { |
| Feature f = (Feature) featIt.next(); |
| mCompiledNameToLanguageMap.put(f.getName(), languages); |
| } |
| } |
| // recurse on subtypes |
| List subtypes = typeSystem.getDirectSubtypes(type); |
| Iterator typeIt = subtypes.iterator(); |
| while (typeIt.hasNext()) { |
| Type subtype = (Type) typeIt.next(); |
| addTypeRecursive(subtype, typeSystem, languages, allFeatures); |
| } |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#containsType(java.lang.String) |
| */ |
| public boolean containsType(String aTypeName) { |
| if (aTypeName.indexOf(TypeSystem.FEATURE_SEPARATOR) != -1) |
| return false; // check against someone passing a feature name here |
| // if compile() has been called can be done by a hash lookup |
| if (!mCompiledNameToLanguageMap.isEmpty()) { |
| return mCompiledNameToLanguageMap.containsKey(aTypeName); |
| } else { |
| // brute force search |
| Iterator it = mTypesAndFeatures.keySet().iterator(); |
| while (it.hasNext()) { |
| TypeOrFeature elem = (TypeOrFeature) it.next(); |
| if (elem.isType() && aTypeName.equals(elem.getName())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#containsType(java.lang.String,java.lang.String) |
| */ |
| public boolean containsType(String aTypeName, String language) { |
| if (language == null) { |
| return containsType(aTypeName); |
| } |
| if (aTypeName.indexOf(TypeSystem.FEATURE_SEPARATOR) != -1) |
| return false; // check against someone passing a feature name here |
| |
| // get language without country if applicable |
| String baseLanguage = null; |
| int index = language.indexOf(LANGUAGE_SEPARATOR); |
| if (index > -1) { |
| baseLanguage = language.substring(0, index); |
| } |
| |
| boolean found = false; |
| |
| if (!mCompiledNameToLanguageMap.isEmpty()) { |
| // if compile() has been called can be done by a hash lookup |
| HashSet languages = (HashSet) mCompiledNameToLanguageMap.get(aTypeName); |
| if (languages != null) { |
| // check if tof is supported for the current language |
| if (UNSPECIFIED_LANGUAGE.equals(language) || languages.contains(language) |
| || languages.contains(UNSPECIFIED_LANGUAGE) || languages.contains(baseLanguage)) { |
| // mark item found |
| found = true; |
| } |
| } |
| } else { |
| // brute force search |
| Iterator it = mTypesAndFeatures.keySet().iterator(); |
| while (it.hasNext()) { |
| TypeOrFeature elem = (TypeOrFeature) it.next(); |
| if (elem.isType() && aTypeName.equals(elem.getName())) { |
| HashSet languages = (HashSet) mTypesAndFeatures.get(elem); |
| if (languages != null) { |
| // check if tof is supported for the current language |
| if (UNSPECIFIED_LANGUAGE.equals(language) || languages.contains(language) |
| || languages.contains(UNSPECIFIED_LANGUAGE) || languages.contains(baseLanguage)) { |
| // mark item found |
| return true; |
| } |
| } |
| } |
| } |
| } |
| |
| return found; |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#containsFeature(java.lang.String) |
| */ |
| public boolean containsFeature(String aFullFeatureName) { |
| if (aFullFeatureName.indexOf(TypeSystem.FEATURE_SEPARATOR) == -1) |
| return false; // check against someone passing a type name here |
| |
| // if compile() has been called can be done by a hash lookup |
| if (!mCompiledNameToLanguageMap.isEmpty()) { |
| return mCompiledNameToLanguageMap.containsKey(aFullFeatureName); |
| } else { |
| // brute force search |
| // (also need to consider Types with allAnnotatorFeatures = true) |
| String typeName = ""; |
| int typeSeparatorIndex = aFullFeatureName.indexOf(':'); |
| if (typeSeparatorIndex > 0) { |
| typeName = aFullFeatureName.substring(0, typeSeparatorIndex); |
| } |
| |
| Iterator it = mTypesAndFeatures.keySet().iterator(); |
| while (it.hasNext()) { |
| TypeOrFeature elem = (TypeOrFeature) it.next(); |
| if ((!elem.isType() && aFullFeatureName.equals(elem.getName())) |
| || (elem.isType() && elem.isAllAnnotatorFeatures() && typeName.equals(elem |
| .getName()))) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#containsFeature(java.lang.String,java.lang.String) |
| */ |
| public boolean containsFeature(String aFullFeatureName, String language) { |
| if (language == null) { |
| return containsFeature(aFullFeatureName); |
| } |
| if (aFullFeatureName.indexOf(TypeSystem.FEATURE_SEPARATOR) == -1) |
| return false; // check against someone passing a type name here |
| |
| // get language without country if applicable |
| String baseLanguage = null; |
| int index = language.indexOf(LANGUAGE_SEPARATOR); |
| if (index > -1) { |
| baseLanguage = language.substring(0, index); |
| } |
| |
| boolean found = false; |
| |
| // if compile() has been called can be done by a hash lookup |
| if (!mCompiledNameToLanguageMap.isEmpty()) { |
| HashSet languages = (HashSet) mCompiledNameToLanguageMap.get(aFullFeatureName); |
| if (languages != null) { |
| // check if tof is supported for the current language |
| if (UNSPECIFIED_LANGUAGE.equals(language) || languages.contains(language) |
| || languages.contains(UNSPECIFIED_LANGUAGE) || languages.contains(baseLanguage)) { |
| // mark item found |
| found = true; |
| } |
| } |
| } else { |
| // brute force search |
| // (also need to consider Types with allAnnotatorFeatures = true) |
| String typeName = ""; |
| int typeSeparatorIndex = aFullFeatureName.indexOf(':'); |
| if (typeSeparatorIndex > 0) { |
| typeName = aFullFeatureName.substring(0, typeSeparatorIndex); |
| } |
| |
| Iterator it = mTypesAndFeatures.keySet().iterator(); |
| while (it.hasNext()) { |
| TypeOrFeature elem = (TypeOrFeature) it.next(); |
| if ((!elem.isType() && aFullFeatureName.equals(elem.getName())) |
| || (elem.isType() && elem.isAllAnnotatorFeatures() && typeName.equals(elem |
| .getName()))) { |
| HashSet languages = (HashSet) mTypesAndFeatures.get(elem); |
| if (languages != null) { |
| // check if tof is supported for the current language |
| if (UNSPECIFIED_LANGUAGE.equals(language) || languages.contains(language) |
| || languages.contains(UNSPECIFIED_LANGUAGE) || languages.contains(baseLanguage)) { |
| // mark item found |
| return true; |
| } |
| } |
| } |
| } |
| } |
| |
| return found; |
| } |
| |
| /** |
| * @see org.apache.uima.resource.impl.MetaDataObject_impl#getXmlizationInfo() |
| */ |
| protected XmlizationInfo getXmlizationInfo() { |
| return new XmlizationInfo("resultSpecification", null, |
| new PropertyXmlInfo[] { new PropertyXmlInfo("resultTypesAndFeatures", null) }); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addCapabilities(org.apache.uima.resource.metadata.Capability[]) |
| */ |
| public void addCapabilities(Capability[] capabilities) { |
| addCapabilities(capabilities, true); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#addCapabilities(org.apache.uima.resource.metadata.Capability[], |
| * boolean) |
| */ |
| public void addCapabilities(Capability[] capabilities, boolean outputs) { |
| if (capabilities != null) { |
| for (int i = 0; i < capabilities.length; i++) { |
| TypeOrFeature[] tofs = outputs ? capabilities[i].getOutputs() : capabilities[i].getInputs(); |
| |
| // get supported languages |
| String[] supportedLanguagesArr = capabilities[i].getLanguagesSupported(); |
| |
| HashSet supportedLanguages = null; |
| if (supportedLanguagesArr != null && supportedLanguagesArr.length > 0) { |
| // create new HashSet with the initial capacity of the supportedLanguageArr |
| supportedLanguages = new HashSet(supportedLanguagesArr.length); |
| // add all supported languages to at HashSet |
| for (int x = 0; x < supportedLanguagesArr.length; x++) { |
| // add current language to the HashSet |
| supportedLanguages.add(supportedLanguagesArr[x]); |
| } |
| } else { |
| // if no languages are set, set default language |
| supportedLanguages = mDefaultLanguage; |
| } |
| |
| for (int y = 0; y < tofs.length; y++) { |
| mTypesAndFeatures.put(tofs[y], supportedLanguages); |
| } |
| |
| } |
| } |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } |
| |
| /** |
| * @see org.apache.uima.analysis_engine.ResultSpecification#removeTypeOrFeature(org.apache.uima.analysis_engine.TypeOrFeature) |
| */ |
| public void removeTypeOrFeature(TypeOrFeature aTypeOrFeature) { |
| // reomve Type or Feature from the |
| mTypesAndFeatures.remove(aTypeOrFeature); |
| // revert to uncompiled state |
| mCompiledNameToLanguageMap.clear(); |
| } |
| |
| /** |
| * returns a clone of the <code>ResultSpecification</code> object. |
| * |
| * @return Object copy of the current object |
| */ |
| public Object clone() { |
| // create new result specification |
| // NOTE: we don't use super.clone here, since for performance reasons |
| // we want to do a faster clone that what the general-purpose logic in |
| // MetaDataObject_impl does. This class is marked final so that |
| // this can't cause a problem if ResultSpecification_impl is subclassed. |
| ResultSpecification_impl newResultSpec = new ResultSpecification_impl(); |
| |
| // clone HashMaps |
| newResultSpec.mTypesAndFeatures = new HashMap(this.mTypesAndFeatures); |
| newResultSpec.mDefaultLanguage = new HashSet(this.mDefaultLanguage); |
| |
| return newResultSpec; |
| } |
| } |
