/** * Create a CollectionReader from an XML descriptor file and a set of configuration parameters. * * @param descriptorPath * The path to the XML descriptor file. * @param configurationData * Any additional configuration parameters to be set. These should be supplied as (name, * value) pairs, so there should always be an even number of parameters. * @return the description created from the XML descriptor and the configuration parameters. * @throws UIMAException * if the descriptor could not be created or if the component could not be instantiated * @throws IOException * if the descriptor could not be read */ public static CollectionReaderDescription createReaderDescriptionFromPath(String descriptorPath, Object... configurationData) throws UIMAException, IOException { ResourceCreationSpecifier specifier = createResourceCreationSpecifier(descriptorPath, configurationData); return (CollectionReaderDescription) specifier; }
public AnalysisEngineDescription getAnnotatorDescription(String modelFileName) throws ResourceInitializationException { AnalysisEngineDescription desc = getBaseDescription(); ResourceCreationSpecifierFactory.setConfigurationParameters( desc, GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH, modelFileName); return desc; }
if ((value != null) && decl.isMultiValued() && !isMultiValue(value)) { value = Array.newInstance(value.getClass(), 1); Array.set(value, 0, configurationValues[i]);
/** * Get an {@link AnalysisEngineDescription} from an XML descriptor file and a set of configuration * parameters. * * @param descriptorPath * The path to the XML descriptor file. * @param configurationData * Any additional configuration parameters to be set. These should be supplied as (name, * value) pairs, so there should always be an even number of parameters. * @return The {@link AnalysisEngineDescription} created from the XML descriptor and the * configuration parameters. * @throws IOException * if an I/O error occurs * @throws InvalidXMLException * if the input XML is not valid or does not specify a valid {@link ResourceSpecifier} */ public static AnalysisEngineDescription createEngineDescriptionFromPath(String descriptorPath, Object... configurationData) throws InvalidXMLException, IOException { ResourceSpecifier specifier; specifier = ResourceCreationSpecifierFactory.createResourceCreationSpecifier(descriptorPath, configurationData); return (AnalysisEngineDescription) specifier; }
/** * Analyze a component for parameters and default values, merge that with parameter values * specified, potentially adding extra parameters. Set the merged result into the provided * descriptor. * * @param desc * the descriptor into which to merge the parameters * @param componentClass * the component class which will be analyzed for parameters. Must match the * implementationName set in the descriptor. * @param configurationParameters * additional parameter names * @param configurationValues * additional parameters values */ public static void setParameters(ResourceCreationSpecifier desc, Class<?> componentClass, ConfigurationParameter[] configurationParameters, Object[] configurationValues) { ConfigurationData reflectedConfigurationData = ConfigurationParameterFactory .createConfigurationData(componentClass); ResourceCreationSpecifierFactory.setConfigurationParameters(desc, reflectedConfigurationData.configurationParameters, reflectedConfigurationData.configurationValues); if (configurationParameters != null) { ResourceCreationSpecifierFactory.setConfigurationParameters(desc, configurationParameters, configurationValues); } }
/** * Parse a ResourceCreationSpecifier from the URL of an XML descriptor file, setting additional * configuration parameters as necessary. * * @param descriptorURL * The URL of the XML descriptor file. * @param parameters * Any additional configuration parameters to be set. These should be supplied as (name, * value) pairs, so there should always be an even number of parameters. * @return The ResourceCreationSpecifier for the XML descriptor with all the configuration * parameters set. * @throws IOException * if an I/O error occurs * @throws InvalidXMLException * if the input XML is not valid or does not specify a valid {@link ResourceSpecifier} */ public static ResourceCreationSpecifier createResourceCreationSpecifier(URL descriptorURL, Object[] parameters) throws InvalidXMLException, IOException { return createResourceCreationSpecifier(new XMLInputSource(descriptorURL), parameters); }
/** * This method adds configuration parameter information to the specifier given the provided * configuration data * * @param specifier * the specified to add the parameters to * @param configurationData * should consist of name value pairs. */ public static void addConfigurationParameters(ResourceCreationSpecifier specifier, Object... configurationData) { ConfigurationData cdata = ConfigurationParameterFactory .createConfigurationData(configurationData); ResourceCreationSpecifierFactory.setConfigurationParameters(specifier, cdata.configurationParameters, cdata.configurationValues); }
/** * Parse a ResourceCreationSpecifier from an XML descriptor file, setting additional configuration * parameters as necessary. * * @param descriptorPath * The path to the XML descriptor file. * @param parameters * Any additional configuration parameters to be set. These should be supplied as (name, * value) pairs, so there should always be an even number of parameters. * @return The ResourceCreationSpecifier for the XML descriptor with all the configuration * parameters set. * @throws IOException * if an I/O error occurs * @throws InvalidXMLException * if the input XML is not valid or does not specify a valid {@link ResourceSpecifier} */ public static ResourceCreationSpecifier createResourceCreationSpecifier(String descriptorPath, Object[] parameters) throws InvalidXMLException, IOException { return createResourceCreationSpecifier(new XMLInputSource(descriptorPath), parameters); }
/** * Adds a single configuration parameter name value pair to a specifier * * @param specifier * the specifier to add the parameter setting to * @param name * the name of the parameter * @param value * the parameter value */ public static void addConfigurationParameter(ResourceCreationSpecifier specifier, String name, Object value) { ConfigurationData cdata = ConfigurationParameterFactory.createConfigurationData(name, value); ResourceCreationSpecifierFactory.setConfigurationParameters(specifier, cdata.configurationParameters, cdata.configurationValues); }
public static AnalysisEngineDescription getConceptMapper(String path, AnalysisEngineDescription tokenDesc) throws UIMAException, IOException, SAXException { String conceptMapper = LEXICA_ROOT + "desc/" + path + "ConceptMapper.xml"; checkArgument(new File(conceptMapper).exists(), "no ConceptMapper file at " + conceptMapper); String lexicon = LEXICA_ROOT + "resources/" + path + ".xml"; checkArgument(new File(lexicon).exists(), "no lexicon file at " + lexicon); AnalysisEngineDescription aed = (AnalysisEngineDescription) createResourceCreationSpecifier( conceptMapper, new Object[] { "TokenizerDescriptorPath", getTokenDescPath(tokenDesc), "Stemmer", SCharsStemmer.class.getName() }); // Create the external resource dependency for the model and bind it ExternalResourceFactory.createDependencyAndBind(aed, "DictionaryFile", DictionaryResource_impl.class, "file:" + lexicon); return aed; } }
/** * This method passes through to * {@link #setConfigurationParameters(ResourceMetaData, ConfigurationParameter[], Object[])} * * @param specifier * The ResourceCreationSpecifier whose parameters are to be set. * @param configurationParameters * the configuration parameter declarations. * @param configurationValues * the configuration parameter values. */ public static void setConfigurationParameters(ResourceCreationSpecifier specifier, ConfigurationParameter[] configurationParameters, Object[] configurationValues) { setConfigurationParameters(specifier.getMetaData(), configurationParameters, configurationValues); }
AnalysisEngineDescription aed = (AnalysisEngineDescription) createResourceCreationSpecifier( conceptMapper, argsArray.toArray());
/** * Provides a mechanism to add configuration parameter information to a specifier for the given * classes. This method may be useful in situations where a class definition has annotated * configuration parameters that you want to include in the given specifier. * * @param specifier * the specified to add the parameters to * @param dynamicallyLoadedClasses * the classes to analyze and extract parameter information from */ public static void addConfigurationParameters(ResourceCreationSpecifier specifier, List<Class<?>> dynamicallyLoadedClasses) { for (Class<?> dynamicallyLoadedClass : dynamicallyLoadedClasses) { ConfigurationData reflectedConfigurationData = ConfigurationParameterFactory .createConfigurationData(dynamicallyLoadedClass); ResourceCreationSpecifierFactory.setConfigurationParameters(specifier, reflectedConfigurationData.configurationParameters, reflectedConfigurationData.configurationValues); } }
} else { u2bDesc = (AnalysisEngineDescription) ResourceCreationSpecifierFactory .createResourceCreationSpecifier(u2bDescPath, null);
/** * Provides a mechanism to add configuration parameter information to a specifier for the given * classes. This method may be useful in situations where a class definition has annotated * configuration parameters that you want to include in the given specifier * * @param specifier * the specified to add the parameters to * @param dynamicallyLoadedClasses * the classes to analyze and extract parameter information from */ public static void addConfigurationParameters(ResourceCreationSpecifier specifier, Class<?>... dynamicallyLoadedClasses) { for (Class<?> dynamicallyLoadedClass : dynamicallyLoadedClasses) { ConfigurationData reflectedConfigurationData = ConfigurationParameterFactory .createConfigurationData(dynamicallyLoadedClass); ResourceCreationSpecifierFactory.setConfigurationParameters(specifier, reflectedConfigurationData.configurationParameters, reflectedConfigurationData.configurationValues); } }
ResourceSpecifier specifier = ResourceCreationSpecifierFactory.createResourceCreationSpecifier( url, configurationData); return (AnalysisEngineDescription) specifier;
public AnalysisEngineDescription getWriterDescription(File outputDirectory) throws ResourceInitializationException { Class<?> dataWriterClass = this.getDataWriterClass(); String paramName; if (SequenceDataWriter.class.isAssignableFrom(dataWriterClass)) { paramName = DefaultSequenceDataWriterFactory.PARAM_DATA_WRITER_CLASS_NAME; } else if (DataWriter.class.isAssignableFrom(dataWriterClass)) { paramName = DefaultDataWriterFactory.PARAM_DATA_WRITER_CLASS_NAME; } else { throw new RuntimeException("Invalid data writer class: " + dataWriterClass); } AnalysisEngineDescription desc = getBaseDescription(); ResourceCreationSpecifierFactory.setConfigurationParameters( desc, DirectoryDataWriterFactory.PARAM_OUTPUT_DIRECTORY, outputDirectory.getPath(), paramName, dataWriterClass.getName()); return desc; }
Import aedImport = (Import) mdo; URL aedUrl = aedImport.findAbsoluteUrl(UIMAFramework.newDefaultResourceManager()); d = (AnalysisEngineDescription) createResourceCreationSpecifier(aedUrl, null);
/** * Create configuration parameter declarations and settings from a list of (name, value) pairs. * * @param specifier * The ResourceCreationSpecifier whose parameters are to be set. * @param configurationData * The configuration parameters to be set. These should be supplied as (name, value) * pairs, so there should always be an even number of parameters. */ public static void setConfigurationParameters(ResourceCreationSpecifier specifier, Object... configurationData) { if (configurationData == null || configurationData.length == 0) { return; } ConfigurationParameterFactory.ensureParametersComeInPairs(configurationData); ConfigurationParameter[] configurationParameters = new ConfigurationParameter[configurationData.length / 2]; Object[] configurationValues = new Object[configurationData.length / 2]; for (int i = 0; i < configurationValues.length; i++) { String name = (String) configurationData[i * 2]; Object value = configurationData[i * 2 + 1]; ConfigurationParameter param = ConfigurationParameterFactory.createPrimitiveParameter(name, value.getClass(), null, false); configurationParameters[i] = param; configurationValues[i] = ConfigurationParameterFactory.convertParameterValue(param, value); } setConfigurationParameters(specifier, configurationParameters, configurationValues); }
/** * Get a CollectionReader from the name (Java-style, dotted) of an XML descriptor file, and a set * of configuration parameters. * * @param descriptorName * The fully qualified, Java-style, dotted name of the XML descriptor file. * @param configurationData * Any additional configuration parameters to be set. These should be supplied as (name, * value) pairs, so there should always be an even number of parameters. * @return The AnalysisEngine created from the XML descriptor and the configuration parameters. * @throws UIMAException * if the descriptor could not be created or if the component could not be instantiated * @throws IOException * if the descriptor could not be read */ public static CollectionReader createReader(String descriptorName, Object... configurationData) throws UIMAException, IOException { Import imp = UIMAFramework.getResourceSpecifierFactory().createImport(); imp.setName(descriptorName); URL url = imp.findAbsoluteUrl(ResourceManagerFactory.newResourceManager()); ResourceSpecifier specifier = createResourceCreationSpecifier(url, configurationData); return UIMAFramework.produceCollectionReader(specifier, ResourceManagerFactory.newResourceManager(), null); }