00001
00002
00003 #include "cheprep/XMLHepRepWriter.h"
00004 #include "cheprep/XMLWriter.h"
00005 #include "cheprep/BHepRepWriter.h"
00006
00007 #include "cheprep/DefaultHepRepInstance.h"
00008 #include "cheprep/DefaultHepRepAttValue.h"
00009
00010 #define NAMESPACE "heprep"
00011
00012 using namespace std;
00013 using namespace HEPREP;
00014
00019 namespace cheprep {
00020
00021 XMLHepRepWriter::XMLHepRepWriter(ostream* os, bool randomAccess, bool useCompression)
00022 : out(os),
00023 compress(useCompression) {
00024
00025 this->nameSpace = NAMESPACE;
00026
00027 if (randomAccess) {
00028 zip = new ZipOutputStream(*os);
00029 out = zip;
00030 gz = NULL;
00031 } else {
00032 zip = NULL;
00033 if (useCompression) {
00034 #ifndef CHEPREP_NO_ZLIB
00035 gz = new GZIPOutputStream(*os);
00036 out = gz;
00037 #else
00038 cerr << "WARNING: the .gz output stream you are creating will be a plain file," << endl;
00039 cerr << "since compression support (ZLIB) was not compiled into the library." << endl;
00040 cerr << "To add ZLIB support, you need to undefine CHEPREP_NO_ZLIB." << endl;
00041 gz = NULL;
00042 #endif
00043 } else {
00044 gz = NULL;
00045 }
00046 }
00047 }
00048
00049 XMLHepRepWriter::~XMLHepRepWriter() {
00050 delete gz;
00051 delete zip;
00052 }
00053
00054 bool XMLHepRepWriter::addProperty(std::string key, std::string value) {
00055 properties[key] = value;
00056 return true;
00057 }
00058
00059 bool XMLHepRepWriter::close() {
00060 if (zip != NULL) {
00061 zip->putNextEntry("heprep.properties", true);
00062
00063 map<string, string>::iterator i = properties.begin();
00064 while (i != properties.end()) {
00065 *zip << (*i).first << "=" << (*i).second << endl;
00066 i++;
00067 }
00068 zip->closeEntry();
00069 zip->close();
00070 }
00071
00072 if (gz != NULL) {
00073 gz->close();
00074 }
00075 return true;
00076 }
00077
00078 bool XMLHepRepWriter::write(HepRep* heprep, string name) {
00079 if (zip != NULL) {
00080 zip->putNextEntry(name, compress);
00081 }
00082
00083 if (name.rfind(".bheprep") == name.length()-8) {
00084 xml = new BHepRepWriter(*out);
00085 } else {
00086 xml = new XMLWriter(out, " ", NAMESPACE);
00087 }
00088
00089 xml->openDoc();
00090 xml->setAttribute("version", (string)"2.0");
00091 xml->setAttribute("xmlns", (string)"http://java.freehep.org/schemas/heprep/2.0");
00092 xml->setAttribute("xmlns", "xsi", "http://www.w3.org/2001/XMLSchema-instance");
00093 xml->setAttribute("xsi", "schemaLocation", "http://java.freehep.org/schemas/heprep/2.0 http://java.freehep.org/schemas/heprep/2.0/HepRep.xsd");
00094 xml->openTag(nameSpace, "heprep");
00095 write(heprep->getLayerOrder());
00096 vector<HepRepTypeTree*> typeTreeSet = heprep->getTypeTreeList();
00097 for (vector<HepRepTypeTree*>::iterator i1=typeTreeSet.begin(); i1 != typeTreeSet.end(); i1++) {
00098 write(*i1);
00099 }
00100 vector<HepRepInstanceTree*> instanceTreeSet = heprep->getInstanceTreeList();
00101 for (vector<HepRepInstanceTree*>::iterator i2=instanceTreeSet.begin(); i2 != instanceTreeSet.end(); i2++) {
00102 write(*i2);
00103 }
00104 xml->closeTag();
00105 xml->closeDoc();
00106
00107 delete xml;
00108
00109 if (zip != NULL) {
00110 zip->closeEntry();
00111 }
00112
00113 return true;
00114 }
00115
00116 bool XMLHepRepWriter::write(vector<string> layers) {
00117 string layerOrder = "";
00118 bool comma = false;
00119 for (vector<string>::iterator i=layers.begin(); i != layers.end(); i++) {
00120 if (comma) {
00121 layerOrder.append(", ");
00122 }
00123 layerOrder.append(*i);
00124 comma = true;
00125 }
00126 xml->setAttribute("order", layerOrder);
00127 xml->printTag(nameSpace, "layer");
00128 return true;
00129 }
00130
00131 bool XMLHepRepWriter::write(HepRepTypeTree* typeTree) {
00132 xml->setAttribute("name", typeTree->getName());
00133 xml->setAttribute("version", typeTree->getVersion());
00134 xml->openTag(nameSpace, "typetree");
00135
00136 vector<HepRepType*> types = typeTree->getTypeList();
00137 for (vector<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) {
00138 write(*i);
00139 }
00140
00141 xml->closeTag();
00142 return true;
00143 }
00144
00145 bool XMLHepRepWriter::write(HepRepType* type) {
00146 xml->setAttribute("name", type->getName());
00147 xml->openTag(nameSpace, "type");
00148 write((HepRepDefinition*)type);
00149 write((HepRepAttribute*)type);
00150
00151 vector<HepRepType*> types = type->getTypeList();
00152 for (vector<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) {
00153 write(*i);
00154 }
00155 xml->closeTag();
00156 return true;
00157 }
00158
00159 bool XMLHepRepWriter::write(HepRepTreeID* treeID) {
00160 xml->setAttribute("qualifier", treeID->getQualifier());
00161 xml->setAttribute("name", treeID->getName());
00162 xml->setAttribute("version", treeID->getVersion());
00163 xml->printTag(nameSpace, "treeid");
00164 return true;
00165 }
00166
00167 bool XMLHepRepWriter::write(HepRepAction* action) {
00168 xml->setAttribute("name", action->getName());
00169 xml->setAttribute("expression", action->getExpression());
00170 xml->printTag(nameSpace, "action");
00171 return true;
00172 }
00173
00174 bool XMLHepRepWriter::write(HepRepInstanceTree* instanceTree) {
00175 xml->setAttribute("name", instanceTree->getName());
00176 xml->setAttribute("version", instanceTree->getVersion());
00177 xml->setAttribute("typetreename", instanceTree->getTypeTree()->getName());
00178 xml->setAttribute("typetreeversion", instanceTree->getTypeTree()->getVersion());
00179 xml->openTag(nameSpace, "instancetree");
00180
00181 vector<HepRepTreeID*> instanceTreeSet = instanceTree->getInstanceTreeList();
00182 for (vector<HepRepTreeID*>::iterator i1=instanceTreeSet.begin(); i1 != instanceTreeSet.end(); i1++) {
00183 write(*i1);
00184 }
00185
00186
00187 vector<HepRepInstance*> instanceList = instanceTree->getInstances();
00188 for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) {
00189 write(*i2);
00190 }
00191 xml->closeTag();
00192 return true;
00193 }
00194
00195 bool XMLHepRepWriter::write(HepRepInstance* instance) {
00196
00197 xml->setAttribute("type", instance->getType()->getFullName());
00198 xml->openTag(nameSpace, "instance");
00199 write((HepRepAttribute*)instance);
00200
00201 vector<HepRepPoint*> pointList = instance->getPoints();
00202 for (vector<HepRepPoint*>::iterator i1=pointList.begin(); i1 != pointList.end(); i1++) {
00203 write(*i1);
00204 }
00205
00206 vector<HepRepInstance*> instanceList = instance->getInstances();
00207 for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) {
00208 write(*i2);
00209 }
00210 xml->closeTag();
00211 return true;
00212 }
00213
00214 bool XMLHepRepWriter::write(HepRepPoint* point) {
00215 xml->setAttribute("x", point->getX());
00216 xml->setAttribute("y", point->getY());
00217 xml->setAttribute("z", point->getZ());
00218 if (point->getAttValuesFromNode().size() != 0) {
00219 xml->openTag(nameSpace, "point");
00220 write((HepRepAttribute*)point);
00221 xml->closeTag();
00222 } else {
00223 xml->printTag(nameSpace, "point");
00224 }
00225 return true;
00226 }
00227
00228 bool XMLHepRepWriter::write(HepRepAttribute* attribute) {
00229
00230
00231 HepRepAttValue* layerAtt = attribute->getAttValueFromNode("layer");
00232 if (layerAtt != NULL) write(layerAtt);
00233
00234 set<HepRepAttValue*> attSet = attribute->getAttValuesFromNode();
00235 for (set<HepRepAttValue*>::iterator i=attSet.begin(); i != attSet.end(); i++) {
00236 write(*i);
00237 }
00238 return true;
00239 }
00240
00241 bool XMLHepRepWriter::write(HepRepDefinition* definition) {
00242 set<HepRepAttDef*> list = definition->getAttDefsFromNode();
00243 for (set<HepRepAttDef*>::iterator i=list.begin(); i != list.end(); i++) {
00244 write(*i);
00245 }
00246 return true;
00247 }
00248
00249 bool XMLHepRepWriter::write(HepRepAttValue* attValue) {
00250 string name = attValue->getName();
00251
00252 xml->setAttribute("name", name);
00253
00254 switch(attValue->getType()) {
00255 default: xml->setAttribute("value", attValue->getAsString());
00256 break;
00257 case HepRepConstants::TYPE_STRING: xml->setAttribute("value", attValue->getString());
00258 break;
00259 case HepRepConstants::TYPE_LONG: xml->setAttribute("value", attValue->getLong());
00260 break;
00261 case HepRepConstants::TYPE_INT: xml->setAttribute("value", attValue->getInteger());
00262 break;
00263 case HepRepConstants::TYPE_DOUBLE: xml->setAttribute("value", attValue->getDouble());
00264 break;
00265 case HepRepConstants::TYPE_BOOLEAN: xml->setAttribute("value", attValue->getBoolean());
00266 break;
00267 case HepRepConstants::TYPE_COLOR: xml->setAttribute("value", attValue->getColor());
00268 }
00269
00270 if (attValue->showLabel() != HepRepConstants::SHOW_NONE) {
00271 xml->setAttribute("showlabel", attValue->showLabel());
00272 }
00273
00274 xml->printTag(nameSpace, "attvalue");
00275 return true;
00276 }
00277
00278 bool XMLHepRepWriter::write(HepRepAttDef* attDef) {
00279 xml->setAttribute("name", attDef->getName());
00280 xml->setAttribute("desc", attDef->getDescription());
00281 xml->setAttribute("category", attDef->getCategory());
00282 xml->setAttribute("extra", attDef->getExtra());
00283 xml->printTag(nameSpace, "attdef");
00284 return true;
00285 }
00286
00287 }
00288