public AnalysisEngineDescription getAnnotatorDescription(String modelFileName) throws ResourceInitializationException { AnalysisEngineDescription desc = getBaseDescription(); ResourceCreationSpecifierFactory.setConfigurationParameters( desc, GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH, modelFileName); return desc; }
/** * 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); }
/** * 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); } }
/** * 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); }
/** * 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); }
/** * 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); } }
/** * 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); } }
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; }
/** * 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); }
/** * This method creates a CollectionReader from a CollectionReaderDescription adding additional * configuration parameter data as desired * * @param desc * a descriptor * @param configurationData * configuration parameter data as name value pairs. Will override values already set in * the description. * @return The CollectionReader created and initialized with the type system and configuration * parameters. * @throws ResourceInitializationException * if the component could not be initialized */ public static CollectionReader createReader(CollectionReaderDescription desc, Object... configurationData) throws ResourceInitializationException { CollectionReaderDescription descClone = (CollectionReaderDescription) desc.clone(); ResourceCreationSpecifierFactory.setConfigurationParameters(descClone, configurationData); return UIMAFramework.produceCollectionReader(descClone, ResourceManagerFactory.newResourceManager(), null); }
/** * Parse a ResourceCreationSpecifier from XML descriptor file input, setting additional * configuration parameters as necessary. * * @param xmlInput * The descriptor file as an XMLInputSource. * @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 InvalidXMLException * if the input XML is not valid or does not specify a valid {@link ResourceSpecifier} */ public static ResourceCreationSpecifier createResourceCreationSpecifier(XMLInputSource xmlInput, Object[] parameters) throws InvalidXMLException { ConfigurationParameterFactory.ensureParametersComeInPairs(parameters); ResourceCreationSpecifier specifier; XMLParser parser = UIMAFramework.getXMLParser(); specifier = (ResourceCreationSpecifier) parser.parseResourceSpecifier(xmlInput); setConfigurationParameters(specifier, parameters); return specifier; }
ResourceCreationSpecifierFactory.setConfigurationParameters(meta, reflectedConfigurationData.configurationParameters, reflectedConfigurationData.configurationValues); ResourceCreationSpecifierFactory.setConfigurationParameters(meta, cfg.configurationParameters, cfg.configurationValues);
ResourceCreationSpecifierFactory.setConfigurationParameters(meta, reflectedConfigurationData.configurationParameters, reflectedConfigurationData.configurationValues); ResourceCreationSpecifierFactory.setConfigurationParameters(meta, cfg.configurationParameters, cfg.configurationValues);
/** * Create and configure a primitive {@link AnalysisEngine}. * * @param desc * the descriptor to create the analysis engine from. * @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 an {@link AnalysisEngine} created from the specified component class and initialized * with the configuration parameters. * @throws ResourceInitializationException * if a failure occurred during production of the resource. * @see <a href="package-summary.html#InstancesVsDescriptors">Why are descriptors better than * component instances?</a> */ public static AnalysisEngine createEngine(AnalysisEngineDescription desc, Object... configurationData) throws ResourceInitializationException { if (configurationData == null || configurationData.length == 0) { return UIMAFramework.produceAnalysisEngine(desc, ResourceManagerFactory.newResourceManager(), null); } else { AnalysisEngineDescription descClone = (AnalysisEngineDescription) desc.clone(); ResourceCreationSpecifierFactory.setConfigurationParameters(descClone, configurationData); return UIMAFramework.produceAnalysisEngine(descClone, ResourceManagerFactory.newResourceManager(), null); } }