in src/cas/xmiwriter.cpp [597:776]
void XmiWriter::writeFSFlat(ostream & os,
FeatureStructure const & fs,
vector<int>* indexInfo) {
uima::internal::CASImpl const & crCASImpl = uima::internal::CASImpl::promoteCAS(iv_cas);
assert( fs.isValid() );
Type t = fs.getType();
lowlevel::TyFSType typecode = uima::internal::FSPromoter::demoteType(t);
XmlElementName * xmlElementName = xmiTypeNames[typecode];
bool insidelist = fs.getCAS().getTypeSystem().isListType(typecode);
int xmiId = /**crCASImpl.getHeap().getUniqueID**/
getXmiId( uima::internal::FSPromoter::demoteFS(fs) );
// if array
if ( iv_arrayType.subsumes(t) ) {
const CAS* ccasp = &iv_cas;
CAS* casp = const_cast<CAS*> (ccasp);
if (casp->getHeap()->getArraySize(internal::FSPromoter::demoteFS(fs)) >0) {
if ( t == iv_intArrayType ) {
writeArray( os, IntArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else if ( t == iv_floatArrayType ) {
writeArray( os, FloatArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else if ( t == iv_stringArrayType ) {
//cout << "got a string array " << endl;
writeStringArray( os, StringArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else if ( t == iv_byteArrayType ) {
writeArray(os, ByteArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else if ( t == iv_booleanArrayType ) {
writeArray( os, BooleanArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else if ( t == iv_shortArrayType ) {
writeArray( os, ShortArrayFS(fs),xmlElementName->qualifiedName.c_str(), xmiId );
} else if ( t == iv_longArrayType ) {
writeArray( os, LongArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else if ( t == iv_doubleArrayType ) {
writeArray( os, DoubleArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else {
assert( t == iv_cas.getTypeSystem().getType(uima::CAS::TYPE_NAME_FS_ARRAY) );
if (internal::FSPromoter::demoteType(t) == internal::gs_tyFSArrayType) {
writeArray( os, ArrayFS(fs), xmlElementName->qualifiedName.c_str(), xmiId);
} else {
cerr << "writeFSFlat unknown array type " << t.getName() << endl;
}
}
}
} else {
vector<Feature> features;
fs.getType().getAppropriateFeatures(features);
size_t i;
stringstream strcontent;
os << " <" << xmlElementName->qualifiedName;
os << " " << ID_ATTR_NAME << "=\"" << getXmiId( uima::internal::FSPromoter::demoteFS(fs) ) << "\"";
bool containsElements=false;
for (i=0; i<features.size(); ++i) {
uima::Feature const & f = features[i];
Type range;
f.getRangeType(range);
int typecode = internal::FSPromoter::demoteType(range);
//cout << "writeFSFlat() " << range.getName() << endl;
switch (typecode) {
case internal::gs_tyBooleanType:
case internal::gs_tyByteType:
case internal::gs_tyIntegerType:
case internal::gs_tyFloatType:
case internal::gs_tyStringType:
case internal::gs_tyShortType:
case internal::gs_tyLongType:
case internal::gs_tyDoubleType: {
writeFeatureValue(os, fs, f);
break;
}
case internal::gs_tyStringArrayType: {
if (f.isMultipleReferencesAllowed() ) {
writeFeatureValue(os, fs, f);
} else {
StringArrayFS arrayFS = fs.getStringArrayFSValue(f);
if (arrayFS.isValid() && arrayFS.size() > 0) {
strcontent << arrayToString(arrayFS, f.getName().asUTF8().c_str());
}
}
break;
}
case internal::gs_tyIntArrayType:
case internal::gs_tyFloatArrayType:
case internal::gs_tyByteArrayType:
case internal::gs_tyBooleanArrayType:
case internal::gs_tyShortArrayType:
case internal::gs_tyLongArrayType:
case internal::gs_tyDoubleArrayType:
case internal::gs_tyFSArrayType: {
if (f.isMultipleReferencesAllowed() ) {
writeFeatureValue(os, fs, f);
} else {
if (fs.getFSValue(f).isValid()) {
string str = arrayToString(fs.getFSValue(f), f.getName().asUTF8().c_str());
os << " " << f.getName() << "=\"" << str << "\" ";
}
}
break;
}
case internal::gs_tyIntListType:
case internal::gs_tyEIntListType:
case internal::gs_tyNEIntListType:
case internal::gs_tyFloatListType:
case internal::gs_tyEFloatListType:
case internal::gs_tyNEFloatListType:
case internal::gs_tyFSListType: {
if (f.isMultipleReferencesAllowed() || insidelist) {
writeFeatureValue(os, fs, f);
} else {
if (fs.getFSValue(f).isValid()) {
string str = listToString(fs.getFSValue(f), f.getName().asUTF8().c_str());
os << " " << f.getName() << "=\"" << str << "\" ";
//cout << " " << range.getName() << str << endl;
}
}
break;
}
case internal::gs_tyStringListType:
case internal::gs_tyEStringListType:
case internal::gs_tyNEStringListType: {
FeatureStructure listFS = fs.getFSValue(f);
if (listFS.isValid()) {
if (f.isMultipleReferencesAllowed() ) {
writeFeatureValue(os, fs, f);
} else {
if (fs.getFSValue(f).isValid()) {
string str = listToString(fs.getFSValue(f), f.getName().asUTF8().c_str());
if (listFS.isValid() && str.length() > 0) {
strcontent << str;
}
}
}
}
break;
}
default: {
writeFeatureValue(os, fs, f);
break;
}
}
}
//add out-of-typesystem features, if any
if (this->sharedData != NULL) {
int fsaddr = internal::FSPromoter::demoteFS(fs);
OotsElementData * oed = this->sharedData->getOutOfTypeSystemFeatures(fsaddr);
if (oed != NULL) {
//attributes
for (size_t a=0; a < oed->attributes.size(); a++) {
XmlAttribute * attr = oed->attributes.at(a);
icu::UnicodeString us;
icu::UnicodeString av(attr->value.c_str());
normalize( av, us );
os << " " << attr->name << "=\"" << us << "\"";
}
//child elements
map<string,vector<string>*>::iterator ite ;
for (ite = oed->childElements.begin();
ite != oed->childElements.end(); ite++) {
vector<string> * values = ite->second;
for (size_t v=0; v < values->size();v++) {
icu::UnicodeString us;
icu::UnicodeString av(values->at(v).c_str());
normalize( av, us );
strcontent << " <" << ite->first
<< ">" << us
<< "</" << ite->first << ">";
}
}
}
}
// write stringArray and/or stringList Features if any
if (strcontent.str().length() > 0) {
os << ">" << strcontent.str();
os << "</" << xmlElementName->qualifiedName << ">" << endl;
strcontent.clear();
} else {
os << "/>" << endl;
}
}
}