private Object getRuntimeValue(AnalysisEngineDescription desc, String attributeName) { String type = desc.getAnalysisEngineMetaData().getConfigurationParameterDeclarations(). getConfigurationParameter(null, attributeName).getType(); // TODO : do it via reflection ? i.e. Class paramType = Class.forName(type)... Object val = null; Object runtimeValue = runtimeParameters.get(attributeName); if (runtimeValue != null) { if ("String".equals(type)) { val = String.valueOf(runtimeValue); } else if ("Integer".equals(type)) { val = Integer.valueOf(runtimeValue.toString()); } else if ("Boolean".equals(type)) { val = Boolean.valueOf(runtimeValue.toString()); } else if ("Float".equals(type)) { val = Float.valueOf(runtimeValue.toString()); } } return val; }
/** * Fixup cpd. */ private void fixupCpd() { if (null == cpd.getConfigurationParameters()) cpd.setConfigurationParameters(AbstractSection.configurationParameterArray0); if (null == cpd.getCommonParameters()) cpd.setCommonParameters(AbstractSection.configurationParameterArray0); if (null == cpd.getConfigurationGroups()) cpd.setConfigurationGroups(AbstractSection.configurationGroupArray0); ConfigurationGroup[] cgs = cpd.getConfigurationGroups(); for (int i = 0; i < cgs.length; i++) { if (null == cgs[i].getConfigurationParameters()) cgs[i].setConfigurationParameters(AbstractSection.configurationParameterArray0); } }
addSelectedParms(delegateCpd.getConfigurationParameters(), keyName); return; addSelectedParms(delegateCpd.getCommonParameters(), keyName); ConfigurationGroup[] dcgs = delegateCpd.getConfigurationGroupDeclarations(groupNames[0]); ArrayList<ConfigurationParameter> cps = new ArrayList<ConfigurationParameter>(); for (ConfigurationGroup dcg : dcgs) { ArrayList<ConfigurationParameter> newCps = new ArrayList<ConfigurationParameter>(); for (ConfigurationParameter cp : cps) { ConfigurationParameter sameCp = delegateCpd.getConfigurationParameter(groupNames[i], cp.getName()); if (sameCp != null) { newCps.add(cp);
/** * Adds the group to model. * * @param newCg the new cg */ private void addGroupToModel(ConfigurationGroup newCg) { ConfigurationGroup[] oldCgs = cpd.getConfigurationGroups(); ConfigurationGroup[] newCgs; if (null == oldCgs) { newCgs = new ConfigurationGroup[1]; } else { newCgs = new ConfigurationGroup[oldCgs.length + 1]; System.arraycopy(oldCgs, 0, newCgs, 0, oldCgs.length); } newCgs[newCgs.length - 1] = newCg; cpd.setConfigurationGroups(newCgs); }
/** * Checks if is parm group. * * @return true, if is parm group */ // ************ public boolean isParmGroup() { ConfigurationParameterDeclarations lcpd = getAnalysisEngineMetaData() .getConfigurationParameterDeclarations(); return (lcpd.getCommonParameters() != null && lcpd.getCommonParameters().length > 0) || (lcpd.getConfigurationGroups() != null && lcpd.getConfigurationGroups().length > 0); }
/** * Parameter name already defined no msg. * * @param name the name * @param pCpd the cpd * @return true, if successful */ public static boolean parameterNameAlreadyDefinedNoMsg(String name, ConfigurationParameterDeclarations pCpd) { if (pCpd.getCommonParameters() != null) { if (parameterInArray(name, pCpd.getCommonParameters())) return true; } if (pCpd.getConfigurationParameters() != null) { if (parameterInArray(name, pCpd.getConfigurationParameters())) return true; } ConfigurationGroup[] groups; if ((groups = pCpd.getConfigurationGroups()) != null) { for (int i = 0; i < groups.length; i++) { if (parameterInArray(name, groups[i].getConfigurationParameters())) return true; } } return false; }
if (cfgParamDecls.getConfigurationParameter(null, resultParam.getName()) != null) { throw new IllegalArgumentException(String.format( "Parameter with name = '%s' exists already")); resultParam.addOverride(delegateKey + "/" + delegateParamName); cfgParamDecls.addConfigurationParameter(resultParam);
public String[] getConfigParameterNames() { ConfigurationParameter[] params = getConfigurationManager().getConfigParameterDeclarations( getQualifiedContextName()).getConfigurationParameters(); if (params == null) { return EMPTY_STRINGS; } else { String[] names = new String[params.length]; for (int i = 0; i < params.length; i++) { names[i] = params[i].getName(); } return names; } }
/** * Gets the config parms. * * @return the config parms */ public ConfigurationParameter[] getConfigParms() { switch (kind) { case NOT_IN_ANY_GROUP: return cpd.getConfigurationParameters(); case COMMON: return cpd.getCommonParameters(); case NAMED_GROUP: return namedCg.getConfigurationParameters(); default: throw new InternalErrorCDE("invalid state"); } }
System.arraycopy(items, 1, removeItems, 0, removeItems.length); removeItems(removeItems, !GIVE_WARNING_MESSAGE); cpd.setCommonParameters(AbstractSection.configurationParameterArray0); cpd.setConfigurationGroups(AbstractSection.configurationGroupArray0); } else if (event.widget == searchStrategy) { valueChanged = false; cpd.setSearchStrategy(setValueChanged(searchStrategy.getText(), cpd.getSearchStrategy())); if (valueChanged) setFileDirty(); } else if (event.widget == defaultGroup) { valueChanged = false; cpd.setDefaultGroupName(setValueChanged(defaultGroup.getText(), cpd.getDefaultGroupName())); if (valueChanged) setFileDirty();
.getConfigurationParameterDeclarations().getConfigurationParameters(); .getConfigurationParameterDeclarations().getConfigurationParameters(); .setConfigurationParameters(candidateNewParams); getAnalysisEngineMetaData().getConfigurationParameterSettings().setParameterSettings( candidateSettings); .setConfigurationParameters(newPlusOldParams);
/** * Removes the group. * * @param itemToRemove the item to remove * @param nameToRemove the name to remove */ private void removeGroup(TreeItem itemToRemove, String nameToRemove) { if (nameToRemove.equals(COMMON_GROUP)) { removeCommonParmSettingsFromMultipleGroups(); cpd.setCommonParameters(configurationParameterArray0); commonParms = configurationParameterArray0; // can't really remove the <Common> group so remove all the parms disposeAllChildItems(itemToRemove); } else if (nameToRemove.equals(NOT_IN_ANY_GROUP)) { // remove settings for all non-group parm definitions removeIncludedParmSettingsFromSingleGroup(NOT_IN_ANY_GROUP, null); cpd.setConfigurationParameters(configurationParameterArray0); // remove all non-group parm definitions disposeAllChildItems(itemToRemove); } else { ConfigurationGroup cg = getConfigurationGroup(nameToRemove); // remove settings for all parms in the group too // also updates the settings GUI if the GUI is initialized removeIncludedParmSettingsFromMultipleGroups(cg.getNames(), cg.getConfigurationParameters()); // remove group cpd.setConfigurationGroups(removeConfigurationGroup(cpd.getConfigurationGroups(), cg)); itemToRemove.dispose(); // also disposes children of group in // GUI } }
aggregateDeclarations.addConfigurationParameter(cfgParam);
groupingControl.setVisible(true); defaultGroup.setText(convertNull(cpd.getDefaultGroupName())); if (null == cpd.getSearchStrategy()) cpd.setSearchStrategy("language_fallback"); searchStrategy.setText(cpd.getSearchStrategy()); } else { groupingControl.setVisible(false);
/** * Gets the all group names. * * @param aCpd the a cpd * @return all named groups, excludes <Common> and <Not in any group> */ protected String[] getAllGroupNames(ConfigurationParameterDeclarations aCpd) { ConfigurationGroup[] cgs = aCpd.getConfigurationGroups(); Set results = new TreeSet(); for (int i = 0; i < cgs.length; i++) { String[] names = cgs[i].getNames(); for (int j = 0; j < names.length; j++) { results.add(names[j]); } } return (String[]) results.toArray(stringArray0); }
public Object getConfigParameterValue(String aQualifiedParameterName, String aGroupName) { // get parameter search strategy for this context ConfigurationParameterDeclarations decls = mContextNameToParamDeclsMap .get(computeParentContextName(aQualifiedParameterName)); if (decls != null) { return getConfigParameterValue(aQualifiedParameterName, aGroupName, decls.getSearchStrategy(), decls.getDefaultGroupName()); } else { return getConfigParameterValue(aQualifiedParameterName, aGroupName, null, null); } }
public String[] getConfigParameterNames(String aGroup) { ConfigurationGroup[] groups = getConfigurationManager().getConfigParameterDeclarations( getQualifiedContextName()).getConfigurationGroupDeclarations(aGroup); if (groups.length == 0) { return EMPTY_STRINGS; } else { List<String> names = new ArrayList<String>(); ConfigurationParameter[] commonParams = getConfigurationManager() .getConfigParameterDeclarations(getQualifiedContextName()).getCommonParameters(); if (commonParams != null) { for (int i = 0; i < commonParams.length; i++) { names.add(commonParams[i].getName()); } } for (int i = 0; i < groups.length; i++) { ConfigurationParameter[] groupParams = groups[i].getConfigurationParameters(); for (int j = 0; j < groupParams.length; j++) { names.add(groupParams[j].getName()); } } String[] nameArray = new String[names.size()]; names.toArray(nameArray); return nameArray; } }
public Object getConfigParameterValue(String aQualifiedParameterName) { // try to look up parameter in no group Object val = lookup(aQualifiedParameterName); if (val != null) { return val; } // if that fails, look up in default group if one is defined String defaultGroup = null; ConfigurationParameterDeclarations decls = mContextNameToParamDeclsMap .get(computeParentContextName(aQualifiedParameterName)); if (decls != null) { defaultGroup = decls.getDefaultGroupName(); } if (defaultGroup != null) { return getConfigParameterValue(aQualifiedParameterName, defaultGroup); } else { return null; } }
disposeAllChildItems(settingGroup); } else { if (getConfigurationParameterDeclarations().getConfigurationGroupDeclarations(groupName).length == 1) { settingGroup.dispose(); } else {
/** * Removes the common parm settings from multiple groups. */ public void removeCommonParmSettingsFromMultipleGroups() { ConfigurationParameterSettings modelSettings = getModelSettings(); String[] allGroupNames = getAllGroupNames(); // TreeItem [] items = new TreeItem[0]; // done to avoid may not have been initialized msg // int offset = 0; commonParms = cpd.getCommonParameters(); for (int i = 0; i < allGroupNames.length; i++) { // if (null != settings) { // items = getSettingsGroupTreeItemByName(allGroupNames[i]).getItems(); // offset = items.length - commonParms.length; // } for (int j = 0; j < commonParms.length; j++) { modelSettings.setParameterValue(allGroupNames[i], commonParms[j].getName(), null); } } if (null != settings) { for (int j = 0; j < commonParms.length; j++) { TreeItem[] settingsParms = getSettingsParameter(null, commonParms[j].getName()); for (int k = 0; k < settingsParms.length; k++) { settingsParms[k].dispose(); } } } }