in src/framework/taespecifier.cpp [1189:1610]
void AnalysisEngineDescription::toXMLBuffer(AnalysisEngineMetaData const & md,
bool isCasConsumer,
icu::UnicodeString & s) const {
size_t i,j;
// AE Meta data
if (isCasConsumer) {
s.append("<processingResourceMetaData>");
} else s.append("<analysisEngineMetaData xmlns=\"http://uima.apache.org/resourceSpecifier\">");
///AnalysisEngineMetaData const & md = * getAnalysisEngineMetaData();
// name
icu::UnicodeString out;
s.append("<name>");
XMLWriterABase::normalize(UnicodeStringRef(md.getName()), out);
s.append(out);
s.append("</name>");
// description
s.append("<description>");
out.setTo("");
XMLWriterABase::normalize(UnicodeStringRef(md.getDescription()), out);
s.append( out );
s.append("</description>");
// version
s.append("<version>");
s.append( md.getVersion() );
s.append("</version>");
// vendor
s.append("<vendor>");
out.setTo("");
XMLWriterABase::normalize(UnicodeStringRef(md.getVendor()), out);
s.append( out );
s.append("</vendor>");
// config params
if (md.hasGroups()) {
s.append("<configurationParameters");
if (md.hasDefaultGroup()) {
s.append(" defaultGroup=\"");
s.append( md.iv_defaultGroup );
s.append("\"");
}
s.append(" searchStrategy=\"");
AnalysisEngineMetaData::EnSearchStrategy searchStrategy = md.getSearchStrategy();
switch (searchStrategy) {
case AnalysisEngineMetaData::DEFAULT_FALLBACK:
s.append("default_fallback");
break;
case AnalysisEngineMetaData::LANGUAGE_FALLBACK:
s.append("language_fallback");
break;
case AnalysisEngineMetaData::NONE:
s.append("none");
break;
}
s.append("\">");
AnalysisEngineMetaData::TyConfigGroup const & confGroups = md.iv_configurationGroups;
assert( confGroups.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS) == confGroups.end() );
AnalysisEngineMetaData::TyConfigGroup::const_iterator cit;
for ( cit = confGroups.begin(); cit != confGroups.end(); ++cit) {
icu::UnicodeString const & confGroupName = (*cit).first;
ConfigurationGroup const & confGroup = (*cit).second;
bool common = ( confGroupName == md.CONFIG_GROUP_NAME_COMMON_PARMS);
if (common) {
s.append("<commonParameters>");
} else {
s.append("<configurationGroup names=\"");
s.append(confGroupName);
s.append("\">");
}
appendConfigGroupToXMLBuffer( confGroup, s);
if (common) {
s.append("</commonParameters>");
} else {
s.append("</configurationGroup>");
}
}
s.append("</configurationParameters>");
} else {
s.append("<configurationParameters>");
AnalysisEngineMetaData::TyConfigGroup const & confGroups = md.iv_configurationGroups;
assert( confGroups.find(md.CONFIG_GROUP_NAME_COMMON_PARMS) == confGroups.end() );
if (confGroups.size() > 0) {
assert( confGroups.size() == 1);
AnalysisEngineMetaData::TyConfigGroup::const_iterator cit = confGroups.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS);
assert( cit != confGroups.end() );
appendConfigGroupToXMLBuffer( (*cit).second, s);
}
s.append("</configurationParameters>");
}
s.append("<configurationParameterSettings>");
// config param settings
if (md.hasGroups()) {
AnalysisEngineMetaData::TyConfigSettings const & confSettings = md.iv_configurationSettings;
AnalysisEngineMetaData::TyConfigSettings::const_iterator cit;
for (cit = confSettings.begin(); cit != confSettings.end(); ++cit) {
icu::UnicodeString const & groupName = (*cit).first;
SettingsForGroup const & settings = (*cit).second;
s.append("<settingsForGroup name=\"");
s.append(groupName);
s.append("\">");
appendConfigGroupSettingsToXMLBuffer(settings, s);
s.append("</settingsForGroup>");
}
} else {
AnalysisEngineMetaData::TyConfigSettings const & confSettings = md.iv_configurationSettings;
if (confSettings.size() > 0) {
assert( confSettings.size() == 1);
AnalysisEngineMetaData::TyConfigSettings::const_iterator cit = confSettings.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS);
assert( cit != confSettings.end() );
appendConfigGroupSettingsToXMLBuffer( (*cit).second, s);
}
}
s.append("</configurationParameterSettings>");
// flow constraints
if (!isPrimitive()) {
s.append("<flowConstraints>");
FlowConstraints const * pFlow = md.getFlowConstraints();
FlowConstraints * flow = CONST_CAST(FlowConstraints *, pFlow);
if (flow->getFlowConstraintsType() == FlowConstraints::FIXED) {
s.append("<fixedFlow>");
} else if (flow->getFlowConstraintsType() == FlowConstraints::CAPABILITYLANGUAGE) {
s.append("<capabilityLanguageFlow>");
}
vector<icu::UnicodeString> const & v = flow->getNodes();
for (i=0; i<v.size(); ++i) {
s.append("<node>");
s.append(v[i]);
s.append("</node>");
}
if (flow->getFlowConstraintsType() == FlowConstraints::FIXED) {
s.append("</fixedFlow>");
} else if (flow->getFlowConstraintsType() == FlowConstraints::CAPABILITYLANGUAGE) {
s.append("</capabilityLanguageFlow>");
}
s.append("</flowConstraints>");
}
//type priorites
const AnalysisEngineMetaData::TyVecpTypePriorities & prioDesc =
md.getTypePriorities();
if (prioDesc.size() > 0) {
s.append("<typePriorities>");
for (i=0; i<prioDesc.size() ;++i) {
s.append("<priorityList>");
TypePriority * prio = prioDesc[i];
vector <icu::UnicodeString> vecTypeOrder = prio->getTypeOrder();
for ( j = 0; j < vecTypeOrder.size(); ++j) {
s.append("<type>");
s.append(vecTypeOrder[j]);
s.append("</type>");
}
s.append("</priorityList>");
}
s.append("</typePriorities>");
}
// type system
s.append("<typeSystemDescription>");
TypeSystemDescription const * typeDesc = md.getTypeSystemDescription();
if (typeDesc != NULL) {
TypeSystemDescription::TyVecpImportDescriptions const & importVec = typeDesc->getImportDescriptions();
s.append("<imports>");
for (i=0; i<importVec.size(); ++i) {
ImportDescription const * pImport = importVec[i];
if ( pImport->getName().length() > 0) {
s.append("<import name=\"");
s.append(pImport->getName());
s.append("\"/>");
} else {
s.append("<import location=\"");
s.append(pImport->getLocation());
s.append("\"/>");
}
}
s.append("</imports><types>");
TypeSystemDescription::TyVecpTypeDescriptions const & tdVec = typeDesc->getTypeDescriptions();
for (i=0; i<tdVec.size(); ++i) {
TypeDescription const * td = tdVec[i];
s.append("<typeDescription>");
s.append("<name>");
s.append(td->getName());
s.append("</name>");
s.append("<description>");
out.setTo("");
XMLWriterABase::normalize(UnicodeStringRef(td->getDescription()), out);
s.append(out);
s.append("</description>");
s.append("<supertypeName>");
s.append(td->getSuperTypeName());
s.append("</supertypeName>");
TypeDescription::TyVecpFeatureDescriptions const & fdVec = td->getFeatureDescriptions();
if (fdVec.size() > 0) {
s.append("<features>");
for (j=0; j<fdVec.size(); ++j) {
FeatureDescription const * fs = fdVec[j];
s.append("<featureDescription>");
s.append("<name>");
s.append(fs->getName());
s.append("</name>");
s.append("<description>");
out.setTo("");
XMLWriterABase::normalize(UnicodeStringRef(fs->getDescription()), out);
s.append(out);
s.append("</description>");
s.append("<rangeTypeName>");
s.append(fs->getRangeTypeName());
s.append("</rangeTypeName>");
if (0 < fs->getElementType().length() ) {
s.append("<elementType>");
s.append(fs->getElementType());
s.append("</elementType>");
}
if (fs->isMultipleReferencesAllowed() ) {
s.append("<multipleReferencesAllowed>");
s.append("true");
s.append("</multipleReferencesAllowed>");
}
s.append("</featureDescription>");
}
s.append("</features>");
}
TypeDescription::TyVecpAllowedValues const & allowVec = td->getAllowedValues();
if (allowVec.size() > 0) {
s.append("<allowedValues>");
for (j=0; j<allowVec.size(); ++j) {
AllowedValue const * value = allowVec[j];
s.append("<value>");
s.append("<string>");
s.append(value->getName());
s.append("</string>");
s.append("<description>");
out.setTo("");
XMLWriterABase::normalize(UnicodeStringRef(value->getDescription()), out);
s.append(out);
s.append("</description>");
s.append("</value>");
}
s.append("</allowedValues>");
}
s.append("</typeDescription>");
}
}
s.append("</types></typeSystemDescription>");
//fsIndexCollection
s.append("<fsIndexCollection>");
//fsIndexCollection -- imports
AnalysisEngineMetaData::TyVecpFSIndexImportDescriptions const & ixImportVec = md.getFSIndexImportDescriptions();
if (ixImportVec.size() > 0 ) {
s.append("<imports>");
for (size_t i=0; i < ixImportVec.size(); i++) {
ImportDescription const * pImport = ixImportVec[i];
if ( pImport->getName().length() > 0) {
s.append("<import name=\"");
s.append(pImport->getName());
s.append("\"/>");
} else {
s.append("<import location=\"");
s.append(pImport->getLocation());
s.append("\"/>");
}
}
s.append("</imports>");
}
// fs indexes
s.append("<fsIndexes>");
AnalysisEngineMetaData::TyVecpFSIndexDescriptions const & ixVec = md.getFSIndexDescriptions();
for (i=0; i<ixVec.size(); ++i) {
FSIndexDescription const * ixDesc = ixVec[i];
s.append("<fsIndexDescription>");
s.append("<label>");
s.append(ixDesc->getLabel());
s.append("</label>");
s.append("<typeName>");
s.append(ixDesc->getTypeName());
s.append("</typeName>");
s.append("<kind>");
FSIndexDescription::EnIndexKind ixKind = ixDesc->getIndexKind();
switch (ixKind) {
case FSIndexDescription::BAG:
s.append("bag");
break;
case FSIndexDescription::SET:
s.append("set");
break;
case FSIndexDescription::SORTED:
s.append("sorted");
break;
default:
assert(false);
}
s.append("</kind>");
FSIndexDescription::TyVecpFSIndexKeys const & keyVec = ixDesc->getFSIndexKeys();
if (keyVec.size() > 0) {
s.append("<keys>");
for (j=0; j<keyVec.size(); ++j) {
s.append("<fsIndexKey>");
FSIndexKeyDescription const * ixKeyDesc = keyVec[j];
if (ixKeyDesc->isTypePriority() ) {
s.append("<typePriority/>");
} else {
s.append("<featureName>");
s.append(ixKeyDesc->getFeatureName());
s.append("</featureName>");
s.append("<comparator>");
FSIndexKeyDescription::EnComparatorType comp = ixKeyDesc->getComparator();
switch (comp) {
case FSIndexKeyDescription::STANDARD:
s.append("standard");
break;
case FSIndexKeyDescription::REVERSE:
s.append("reverse");
break;
default:
assert(false);
}
s.append("</comparator>");
}
s.append("</fsIndexKey>");
}
s.append("</keys>");
}
s.append("</fsIndexDescription>");
}
s.append("</fsIndexes>");
s.append("</fsIndexCollection>");
// capabilities
s.append("<capabilities>");
AnalysisEngineMetaData::TyVecpCapabilities const & capVec = md.getCapabilites();
for (i=0; i<capVec.size(); ++i) {
Capability const * cap = capVec[i];
s.append("<capability>");
s.append("<inputs>");
appendCapabilities( cap->getCapabilityTypes(Capability::INPUT), "type", s);
appendCapabilities( cap->getCapabilityFeatures(Capability::INPUT), "feature", s);
s.append("</inputs>");
s.append("<outputs>");
appendCapabilities( cap->getCapabilityTypes(Capability::OUTPUT), "type", s);
appendCapabilities( cap->getCapabilityFeatures(Capability::OUTPUT), "feature", s);
s.append("</outputs>");
s.append("<inputSofas>");
appendCapabilities( cap->getCapabilitySofas(Capability::INPUTSOFA), "sofaName", s);
s.append("</inputSofas>");
s.append("<outputSofas>");
appendCapabilities( cap->getCapabilitySofas(Capability::OUTPUTSOFA), "sofaName", s);
s.append("</outputSofas>");
s.append("<languagesSupported>");
Capability::TyVecCapabilityLanguages const & suppLangVec = cap->getSupportedLanguages();
for (j=0; j<suppLangVec.size(); ++j) {
s.append("<language>");
s.append(suppLangVec[j]);
s.append("</language>");
}
s.append("</languagesSupported>");
s.append("</capability>");
}
s.append("</capabilities>");
if (this->getAnalysisEngineMetaData()->getOperationalProperties() != 0) {
s.append("<operationalProperties>");
s.append ("<modifiesCas>");
appendBool(this->getAnalysisEngineMetaData()->getOperationalProperties()->getModifiesCas(), s);
s.append ("</modifiesCas>");
s.append ("<multipleDeploymentAllowed>");
appendBool(this->getAnalysisEngineMetaData()->getOperationalProperties()->isMultipleDeploymentAllowed(), s);
s.append("</multipleDeploymentAllowed>");
s.append("<outputsNewCASes>");
appendBool(this->getAnalysisEngineMetaData()->getOperationalProperties()->getOutputsNewCASes(), s);
s.append("</outputsNewCASes>");
s.append("</operationalProperties>");
} else {
s.append("<operationalProperties>");
s.append ("<modifiesCas>true</modifiesCas>");
s.append("<multipleDeploymentAllowed>true</multipleDeploymentAllowed>");
s.append("<outputsNewCASes>false</outputsNewCASes>");
s.append("</operationalProperties>");
}
if (isCasConsumer) {
s.append("</processingResourceMetaData>");
} else s.append("</analysisEngineMetaData>");
}