[834] | 1 | // Copyright FreeHEP, 2005. |
---|
| 2 | |
---|
| 3 | #include "cheprep/XMLHepRepWriter.h" |
---|
| 4 | #include "cheprep/XMLWriter.h" |
---|
| 5 | #include "cheprep/BHepRepWriter.h" |
---|
| 6 | |
---|
| 7 | #include "cheprep/DefaultHepRepInstance.h" |
---|
| 8 | #include "cheprep/DefaultHepRepAttValue.h" |
---|
| 9 | |
---|
| 10 | #define NAMESPACE "heprep" |
---|
| 11 | |
---|
| 12 | using namespace std; |
---|
| 13 | using namespace HEPREP; |
---|
| 14 | |
---|
| 15 | /** |
---|
| 16 | * @author Mark Donszelmann |
---|
| 17 | * @version $Id: XMLHepRepWriter.cc,v 1.15 2005/06/02 21:28:45 duns Exp $ |
---|
| 18 | */ |
---|
| 19 | namespace cheprep { |
---|
| 20 | |
---|
| 21 | XMLHepRepWriter::XMLHepRepWriter(ostream* os, bool randomAccess, bool useCompression) |
---|
| 22 | : out(os), |
---|
| 23 | compress(useCompression) { |
---|
| 24 | |
---|
| 25 | this->nameSpace = NAMESPACE; |
---|
| 26 | |
---|
| 27 | if (randomAccess) { |
---|
| 28 | zip = new ZipOutputStream(*os); |
---|
| 29 | out = zip; |
---|
| 30 | gz = NULL; |
---|
| 31 | } else { |
---|
| 32 | zip = NULL; |
---|
| 33 | if (useCompression) { |
---|
| 34 | #ifndef CHEPREP_NO_ZLIB |
---|
| 35 | gz = new GZIPOutputStream(*os); |
---|
| 36 | out = gz; |
---|
| 37 | #else |
---|
| 38 | cerr << "WARNING: the .gz output stream you are creating will be a plain file," << endl; |
---|
| 39 | cerr << "since compression support (ZLIB) was not compiled into the library." << endl; |
---|
| 40 | cerr << "To add ZLIB support, you need to undefine CHEPREP_NO_ZLIB." << endl; |
---|
| 41 | gz = NULL; |
---|
| 42 | #endif |
---|
| 43 | } else { |
---|
| 44 | gz = NULL; |
---|
| 45 | } |
---|
| 46 | } |
---|
| 47 | } |
---|
| 48 | |
---|
| 49 | XMLHepRepWriter::~XMLHepRepWriter() { |
---|
| 50 | delete gz; |
---|
| 51 | delete zip; |
---|
| 52 | } |
---|
| 53 | |
---|
| 54 | bool XMLHepRepWriter::addProperty(std::string key, std::string value) { |
---|
| 55 | properties[key] = value; |
---|
| 56 | return true; |
---|
| 57 | } |
---|
| 58 | |
---|
| 59 | bool XMLHepRepWriter::close() { |
---|
| 60 | if (zip != NULL) { |
---|
| 61 | zip->putNextEntry("heprep.properties", true); |
---|
| 62 | |
---|
| 63 | map<string, string>::iterator i = properties.begin(); |
---|
| 64 | while (i != properties.end()) { |
---|
| 65 | *zip << (*i).first << "=" << (*i).second << endl; |
---|
| 66 | i++; |
---|
| 67 | } |
---|
| 68 | zip->closeEntry(); |
---|
| 69 | zip->close(); |
---|
| 70 | } |
---|
| 71 | |
---|
| 72 | if (gz != NULL) { |
---|
| 73 | gz->close(); |
---|
| 74 | } |
---|
| 75 | return true; |
---|
| 76 | } |
---|
| 77 | |
---|
| 78 | bool XMLHepRepWriter::write(HepRep* heprep, string name) { |
---|
| 79 | if (zip != NULL) { |
---|
| 80 | zip->putNextEntry(name, compress); |
---|
| 81 | } |
---|
| 82 | |
---|
| 83 | if (name.rfind(".bheprep") == name.length()-8) { |
---|
| 84 | xml = new BHepRepWriter(*out); |
---|
| 85 | } else { |
---|
| 86 | xml = new XMLWriter(out, " ", NAMESPACE); |
---|
| 87 | } |
---|
| 88 | |
---|
| 89 | xml->openDoc(); |
---|
| 90 | xml->setAttribute("version", (string)"2.0"); |
---|
| 91 | xml->setAttribute("xmlns", (string)"http://java.freehep.org/schemas/heprep/2.0"); |
---|
| 92 | xml->setAttribute("xmlns", "xsi", "http://www.w3.org/2001/XMLSchema-instance"); |
---|
| 93 | xml->setAttribute("xsi", "schemaLocation", "http://java.freehep.org/schemas/heprep/2.0 http://java.freehep.org/schemas/heprep/2.0/HepRep.xsd"); |
---|
| 94 | xml->openTag(nameSpace, "heprep"); |
---|
| 95 | write(heprep->getLayerOrder()); |
---|
| 96 | vector<HepRepTypeTree*> typeTreeSet = heprep->getTypeTreeList(); |
---|
| 97 | for (vector<HepRepTypeTree*>::iterator i1=typeTreeSet.begin(); i1 != typeTreeSet.end(); i1++) { |
---|
| 98 | write(*i1); |
---|
| 99 | } |
---|
| 100 | vector<HepRepInstanceTree*> instanceTreeSet = heprep->getInstanceTreeList(); |
---|
| 101 | for (vector<HepRepInstanceTree*>::iterator i2=instanceTreeSet.begin(); i2 != instanceTreeSet.end(); i2++) { |
---|
| 102 | write(*i2); |
---|
| 103 | } |
---|
| 104 | xml->closeTag(); |
---|
| 105 | xml->closeDoc(); |
---|
| 106 | // xml->close(); |
---|
| 107 | delete xml; |
---|
| 108 | |
---|
| 109 | if (zip != NULL) { |
---|
| 110 | zip->closeEntry(); |
---|
| 111 | } |
---|
| 112 | |
---|
| 113 | return true; |
---|
| 114 | } |
---|
| 115 | |
---|
| 116 | bool XMLHepRepWriter::write(vector<string> layers) { |
---|
| 117 | string layerOrder = ""; |
---|
| 118 | bool comma = false; |
---|
| 119 | for (vector<string>::iterator i=layers.begin(); i != layers.end(); i++) { |
---|
| 120 | if (comma) { |
---|
| 121 | layerOrder.append(", "); |
---|
| 122 | } |
---|
| 123 | layerOrder.append(*i); |
---|
| 124 | comma = true; |
---|
| 125 | } |
---|
| 126 | xml->setAttribute("order", layerOrder); |
---|
| 127 | xml->printTag(nameSpace, "layer"); |
---|
| 128 | return true; |
---|
| 129 | } |
---|
| 130 | |
---|
| 131 | bool XMLHepRepWriter::write(HepRepTypeTree* typeTree) { |
---|
| 132 | xml->setAttribute("name", typeTree->getName()); |
---|
| 133 | xml->setAttribute("version", typeTree->getVersion()); |
---|
| 134 | xml->openTag(nameSpace, "typetree"); |
---|
| 135 | |
---|
| 136 | vector<HepRepType*> types = typeTree->getTypeList(); |
---|
| 137 | for (vector<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) { |
---|
| 138 | write(*i); |
---|
| 139 | } |
---|
| 140 | |
---|
| 141 | xml->closeTag(); |
---|
| 142 | return true; |
---|
| 143 | } |
---|
| 144 | |
---|
| 145 | bool XMLHepRepWriter::write(HepRepType* type) { |
---|
| 146 | xml->setAttribute("name", type->getName()); |
---|
| 147 | xml->openTag(nameSpace, "type"); |
---|
| 148 | write((HepRepDefinition*)type); |
---|
| 149 | write((HepRepAttribute*)type); |
---|
| 150 | |
---|
| 151 | vector<HepRepType*> types = type->getTypeList(); |
---|
| 152 | for (vector<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) { |
---|
| 153 | write(*i); |
---|
| 154 | } |
---|
| 155 | xml->closeTag(); |
---|
| 156 | return true; |
---|
| 157 | } |
---|
| 158 | |
---|
| 159 | bool XMLHepRepWriter::write(HepRepTreeID* treeID) { |
---|
| 160 | xml->setAttribute("qualifier", treeID->getQualifier()); |
---|
| 161 | xml->setAttribute("name", treeID->getName()); |
---|
| 162 | xml->setAttribute("version", treeID->getVersion()); |
---|
| 163 | xml->printTag(nameSpace, "treeid"); |
---|
| 164 | return true; |
---|
| 165 | } |
---|
| 166 | |
---|
| 167 | bool XMLHepRepWriter::write(HepRepAction* action) { |
---|
| 168 | xml->setAttribute("name", action->getName()); |
---|
| 169 | xml->setAttribute("expression", action->getExpression()); |
---|
| 170 | xml->printTag(nameSpace, "action"); |
---|
| 171 | return true; |
---|
| 172 | } |
---|
| 173 | |
---|
| 174 | bool XMLHepRepWriter::write(HepRepInstanceTree* instanceTree) { |
---|
| 175 | xml->setAttribute("name", instanceTree->getName()); |
---|
| 176 | xml->setAttribute("version", instanceTree->getVersion()); |
---|
| 177 | xml->setAttribute("typetreename", instanceTree->getTypeTree()->getName()); |
---|
| 178 | xml->setAttribute("typetreeversion", instanceTree->getTypeTree()->getVersion()); |
---|
| 179 | xml->openTag(nameSpace, "instancetree"); |
---|
| 180 | // refs |
---|
| 181 | vector<HepRepTreeID*> instanceTreeSet = instanceTree->getInstanceTreeList(); |
---|
| 182 | for (vector<HepRepTreeID*>::iterator i1=instanceTreeSet.begin(); i1 != instanceTreeSet.end(); i1++) { |
---|
| 183 | write(*i1); |
---|
| 184 | } |
---|
| 185 | |
---|
| 186 | // instances |
---|
| 187 | vector<HepRepInstance*> instanceList = instanceTree->getInstances(); |
---|
| 188 | for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) { |
---|
| 189 | write(*i2); |
---|
| 190 | } |
---|
| 191 | xml->closeTag(); |
---|
| 192 | return true; |
---|
| 193 | } |
---|
| 194 | |
---|
| 195 | bool XMLHepRepWriter::write(HepRepInstance* instance) { |
---|
| 196 | // FIXME FREEHEP-356 |
---|
| 197 | xml->setAttribute("type", instance->getType()->getFullName()); |
---|
| 198 | xml->openTag(nameSpace, "instance"); |
---|
| 199 | write((HepRepAttribute*)instance); |
---|
| 200 | |
---|
| 201 | vector<HepRepPoint*> pointList = instance->getPoints(); |
---|
| 202 | for (vector<HepRepPoint*>::iterator i1=pointList.begin(); i1 != pointList.end(); i1++) { |
---|
| 203 | write(*i1); |
---|
| 204 | } |
---|
| 205 | |
---|
| 206 | vector<HepRepInstance*> instanceList = instance->getInstances(); |
---|
| 207 | for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) { |
---|
| 208 | write(*i2); |
---|
| 209 | } |
---|
| 210 | xml->closeTag(); |
---|
| 211 | return true; |
---|
| 212 | } |
---|
| 213 | |
---|
| 214 | bool XMLHepRepWriter::write(HepRepPoint* point) { |
---|
| 215 | xml->setAttribute("x", point->getX()); |
---|
| 216 | xml->setAttribute("y", point->getY()); |
---|
| 217 | xml->setAttribute("z", point->getZ()); |
---|
| 218 | if (point->getAttValuesFromNode().size() != 0) { |
---|
| 219 | xml->openTag(nameSpace, "point"); |
---|
| 220 | write((HepRepAttribute*)point); |
---|
| 221 | xml->closeTag(); |
---|
| 222 | } else { |
---|
| 223 | xml->printTag(nameSpace, "point"); |
---|
| 224 | } |
---|
| 225 | return true; |
---|
| 226 | } |
---|
| 227 | |
---|
| 228 | bool XMLHepRepWriter::write(HepRepAttribute* attribute) { |
---|
| 229 | // BUG FIX. Do something special for layers, because these do not end |
---|
| 230 | // up in the normal iteration. |
---|
| 231 | HepRepAttValue* layerAtt = attribute->getAttValueFromNode("layer"); |
---|
| 232 | if (layerAtt != NULL) write(layerAtt); |
---|
| 233 | |
---|
| 234 | set<HepRepAttValue*> attSet = attribute->getAttValuesFromNode(); |
---|
| 235 | for (set<HepRepAttValue*>::iterator i=attSet.begin(); i != attSet.end(); i++) { |
---|
| 236 | write(*i); |
---|
| 237 | } |
---|
| 238 | return true; |
---|
| 239 | } |
---|
| 240 | |
---|
| 241 | bool XMLHepRepWriter::write(HepRepDefinition* definition) { |
---|
| 242 | set<HepRepAttDef*> list = definition->getAttDefsFromNode(); |
---|
| 243 | for (set<HepRepAttDef*>::iterator i=list.begin(); i != list.end(); i++) { |
---|
| 244 | write(*i); |
---|
| 245 | } |
---|
| 246 | return true; |
---|
| 247 | } |
---|
| 248 | |
---|
| 249 | bool XMLHepRepWriter::write(HepRepAttValue* attValue) { |
---|
| 250 | string name = attValue->getName(); |
---|
| 251 | |
---|
| 252 | xml->setAttribute("name", name); |
---|
| 253 | |
---|
| 254 | switch(attValue->getType()) { |
---|
| 255 | default: xml->setAttribute("value", attValue->getAsString()); |
---|
| 256 | break; |
---|
| 257 | case HepRepConstants::TYPE_STRING: xml->setAttribute("value", attValue->getString()); |
---|
| 258 | break; |
---|
| 259 | case HepRepConstants::TYPE_LONG: xml->setAttribute("value", attValue->getLong()); |
---|
| 260 | break; |
---|
| 261 | case HepRepConstants::TYPE_INT: xml->setAttribute("value", attValue->getInteger()); |
---|
| 262 | break; |
---|
| 263 | case HepRepConstants::TYPE_DOUBLE: xml->setAttribute("value", attValue->getDouble()); |
---|
| 264 | break; |
---|
| 265 | case HepRepConstants::TYPE_BOOLEAN: xml->setAttribute("value", attValue->getBoolean()); |
---|
| 266 | break; |
---|
| 267 | case HepRepConstants::TYPE_COLOR: xml->setAttribute("value", attValue->getColor()); |
---|
| 268 | } |
---|
| 269 | |
---|
| 270 | if (attValue->showLabel() != HepRepConstants::SHOW_NONE) { |
---|
| 271 | xml->setAttribute("showlabel", attValue->showLabel()); |
---|
| 272 | } |
---|
| 273 | |
---|
| 274 | xml->printTag(nameSpace, "attvalue"); |
---|
| 275 | return true; |
---|
| 276 | } |
---|
| 277 | |
---|
| 278 | bool XMLHepRepWriter::write(HepRepAttDef* attDef) { |
---|
| 279 | xml->setAttribute("name", attDef->getName()); |
---|
| 280 | xml->setAttribute("desc", attDef->getDescription()); |
---|
| 281 | xml->setAttribute("category", attDef->getCategory()); |
---|
| 282 | xml->setAttribute("extra", attDef->getExtra()); |
---|
| 283 | xml->printTag(nameSpace, "attdef"); |
---|
| 284 | return true; |
---|
| 285 | } |
---|
| 286 | |
---|
| 287 | } // cheprep |
---|
| 288 | |
---|