cheprep::XMLHepRepWriter Class Reference

#include <XMLHepRepWriter.h>

Inheritance diagram for cheprep::XMLHepRepWriter:

Public Member Functions
	XMLHepRepWriter (std::ostream *out, bool randomAccess, bool compress)
	~XMLHepRepWriter ()
bool	addProperty (std::string key, std::string value)
bool	close ()
bool	write (HEPREP::HepRep *heprep, std::string name)
bool	write (std::vector< std::string > layers)
bool	write (HEPREP::HepRepTypeTree *typeTree)
bool	write (HEPREP::HepRepType *type)
bool	write (HEPREP::HepRepTreeID *treeID)
bool	write (HEPREP::HepRepAction *action)
bool	write (HEPREP::HepRepInstanceTree *instanceTree)
bool	write (HEPREP::HepRepInstance *instance)
bool	write (HEPREP::HepRepPoint *point)
bool	write (HEPREP::HepRepAttribute *attribute)
bool	write (HEPREP::HepRepDefinition *definition)
bool	write (HEPREP::HepRepAttValue *attValue)
bool	write (HEPREP::HepRepAttDef *attDef)
Public Member Functions inherited from HEPREP::HepRepWriter
virtual	~HepRepWriter ()
	Destructor.
virtual bool	addProperty (std::string key, std::string value)=0
virtual bool	close ()=0
virtual bool	write (HepRep *heprep, std::string name)=0
virtual bool	write (std::vector< std::string > layerOrder)=0
virtual bool	write (HepRepTypeTree *typeTree)=0
virtual bool	write (HepRepType *type)=0
virtual bool	write (HepRepTreeID *treeID)=0
virtual bool	write (HepRepAction *action)=0
virtual bool	write (HepRepInstanceTree *instanceTree)=0
virtual bool	write (HepRepInstance *instance)=0
virtual bool	write (HepRepPoint *point)=0
virtual bool	write (HepRepAttribute *attribute)=0
virtual bool	write (HepRepDefinition *definition)=0
virtual bool	write (HepRepAttValue *attValue)=0
virtual bool	write (HepRepAttDef *attDef)=0

Detailed Description

Definition at line 37 of file XMLHepRepWriter.h.

Constructor & Destructor Documentation

XMLHepRepWriter()

cheprep::XMLHepRepWriter::XMLHepRepWriter	(	std::ostream *	out,
		bool	randomAccess,
		bool	compress
	)

Definition at line 20 of file XMLHepRepWriter.cc.

        : out(os),
          compress(useCompression),
          xml(0) {
            
    this->nameSpace = NAMESPACE;
 
    if (randomAccess) {
        zip = new ZipOutputStream(*os);
        out = zip;
        gz = NULL;
    } else {
        zip = NULL;
        if (useCompression) {
#ifndef CHEPREP_NO_ZLIB
            gz = new GZIPOutputStream(*os);
            out = gz;
#else
            cerr << "WARNING: the .gz output stream you are creating will be a plain file," << endl;
            cerr << "since compression support (ZLIB) was not compiled into the library." << endl;
            cerr << "To add ZLIB support, you need to undefine CHEPREP_NO_ZLIB." << endl;  
            gz = NULL;            
#endif
        } else {
            gz = NULL;
        }
    }
}

~XMLHepRepWriter()

cheprep::XMLHepRepWriter::~XMLHepRepWriter

(

)

Definition at line 49 of file XMLHepRepWriter.cc.

                                  {
    delete gz;
    delete zip;
}

Member Function Documentation

addProperty()

bool cheprep::XMLHepRepWriter::addProperty ( std::string  key, std::string  value  )

virtual

Adds a property, to be written to the HepRep file when closed.

Parameters

key
value

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 54 of file XMLHepRepWriter.cc.

                                                                {
    properties[key] = value;
    return true;
}

close()

bool cheprep::XMLHepRepWriter::close ( )

virtual

Closes the writer and its underlying stream.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 59 of file XMLHepRepWriter.cc.

                            {
    if (zip != NULL) {
        zip->putNextEntry("heprep.properties", true);
        
        map<string, string>::iterator i = properties.begin();
        while (i != properties.end()) {
            *zip << (*i).first << "=" << (*i).second << endl;
            i++;
        }
        zip->closeEntry();
        zip->close();
    }
 
    if (gz != NULL) {
        gz->close();
    }
    return true;
}

write() [1/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRep *  heprep, std::string  name  )

virtual

Writes a HepRep.

Parameters

heprep	to be written.
name	for the heprep to be written (for tagged access), may be ommited.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 78 of file XMLHepRepWriter.cc.

                                                       {
    if (zip != NULL) {
        zip->putNextEntry(name, compress);
    }
    
    if (name.rfind(".bheprep") == name.length()-8) {
       xml = new BHepRepWriter(*out);
    } else { 
       xml = new XMLWriter(out, "  ", NAMESPACE);
    }
            
    xml->openDoc();
    xml->setAttribute("version", (string)"2.0");
    xml->setAttribute("xmlns", (string)"http://java.freehep.org/schemas/heprep/2.0");
    xml->setAttribute("xmlns", "xsi", "http://www.w3.org/2001/XMLSchema-instance");
    xml->setAttribute("xsi", "schemaLocation", "http://java.freehep.org/schemas/heprep/2.0 http://java.freehep.org/schemas/heprep/2.0/HepRep.xsd");
    xml->openTag(nameSpace, "heprep");
    write(heprep->getLayerOrder());
    vector<HepRepTypeTree*> typeTreeSet = heprep->getTypeTreeList();
    for (vector<HepRepTypeTree*>::iterator i1=typeTreeSet.begin(); i1 != typeTreeSet.end(); i1++) {
        write(*i1);
    }
    vector<HepRepInstanceTree*> instanceTreeSet = heprep->getInstanceTreeList();
    for (vector<HepRepInstanceTree*>::iterator i2=instanceTreeSet.begin(); i2 != instanceTreeSet.end(); i2++) {
        write(*i2);
    }
    xml->closeTag();
    xml->closeDoc();
//    xml->close();
    delete xml;
   
    if (zip != NULL) {
        zip->closeEntry();
    }
 
    return true;
}

Referenced by write().

write() [2/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepAction *  action )

virtual

Writes a HepRepAction.

Parameters

action

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 167 of file XMLHepRepWriter.cc.

                                                {
    xml->setAttribute("name", action->getName());
    xml->setAttribute("expression", action->getExpression());
    xml->printTag(nameSpace, "action");
    return true;
}

write() [3/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepAttDef *  attDef )

virtual

Writes a HepRepAttDef.

Parameters

attDef

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 278 of file XMLHepRepWriter.cc.

                                                {
    xml->setAttribute("name", attDef->getName());
    xml->setAttribute("desc", attDef->getDescription());
    xml->setAttribute("category", attDef->getCategory());
    xml->setAttribute("extra", attDef->getExtra());
    xml->printTag(nameSpace, "attdef");
    return true;
}

write() [4/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepAttribute *  attribute )

virtual

Writes a HepRepAttribute.

Parameters

attribute

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 228 of file XMLHepRepWriter.cc.

                                                      {
    // BUG FIX.  Do something special for layers, because these do not end
    // up in the normal iteration.
    HepRepAttValue* layerAtt = attribute->getAttValueFromNode("layer");
    if (layerAtt != NULL) write(layerAtt);
 
    set<HepRepAttValue*> attSet = attribute->getAttValuesFromNode();
    for (set<HepRepAttValue*>::iterator i=attSet.begin(); i != attSet.end(); i++) {
        write(*i);
    }
    return true;
}

write() [5/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepAttValue *  attValue )

virtual

Writes a HepRepAttValue.

Parameters

attValue

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 249 of file XMLHepRepWriter.cc.

                                                    {
    string name = attValue->getName();
 
    xml->setAttribute("name", name);
 
    switch(attValue->getType()) {
        default:                            xml->setAttribute("value", attValue->getAsString());
                                            break;                           
        case HepRepConstants::TYPE_STRING:  xml->setAttribute("value", attValue->getString());
                                            break;
        case HepRepConstants::TYPE_LONG:    xml->setAttribute("value", attValue->getLong());
                                            break;
        case HepRepConstants::TYPE_INT:     xml->setAttribute("value", attValue->getInteger());
                                            break;
        case HepRepConstants::TYPE_DOUBLE:  xml->setAttribute("value", attValue->getDouble());
                                            break;
        case HepRepConstants::TYPE_BOOLEAN: xml->setAttribute("value", attValue->getBoolean());
                                            break;
        case HepRepConstants::TYPE_COLOR:   xml->setAttribute("value", attValue->getColor());
    }
 
    if (attValue->showLabel() != HepRepConstants::SHOW_NONE) {
        xml->setAttribute("showlabel", attValue->showLabel());
    }
 
    xml->printTag(nameSpace, "attvalue");
    return true;
}

write() [6/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepDefinition *  definition )

virtual

Writes a HepRepDefinition.

Parameters

definition

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 241 of file XMLHepRepWriter.cc.

                                                        {
    set<HepRepAttDef*> list = definition->getAttDefsFromNode();
    for (set<HepRepAttDef*>::iterator i=list.begin(); i != list.end(); i++) {
        write(*i);
    }
    return true;
}

write() [7/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepInstance *  instance )

virtual

Writes a HepRepInstance.

Parameters

instance

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 195 of file XMLHepRepWriter.cc.

                                                    {
    // FIXME FREEHEP-356
    xml->setAttribute("type", instance->getType()->getFullName());
    xml->openTag(nameSpace, "instance");
    write((HepRepAttribute*)instance);
 
    vector<HepRepPoint*> pointList = instance->getPoints();
    for (vector<HepRepPoint*>::iterator i1=pointList.begin(); i1 != pointList.end(); i1++) {
        write(*i1);
    }
 
    vector<HepRepInstance*> instanceList = instance->getInstances();
    for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) {
        write(*i2);
    }
    xml->closeTag();
    return true;
}

write() [8/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepInstanceTree *  instanceTree )

virtual

Writes a HepRepInstanceTree.

Parameters

instanceTree

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 174 of file XMLHepRepWriter.cc.

                                                            {
    xml->setAttribute("name", instanceTree->getName());
    xml->setAttribute("version", instanceTree->getVersion());
    xml->setAttribute("typetreename", instanceTree->getTypeTree()->getName());
    xml->setAttribute("typetreeversion", instanceTree->getTypeTree()->getVersion());
    xml->openTag(nameSpace, "instancetree");
    // refs
    vector<HepRepTreeID*> instanceTreeSet = instanceTree->getInstanceTreeList();
    for (vector<HepRepTreeID*>::iterator i1=instanceTreeSet.begin(); i1 != instanceTreeSet.end(); i1++) {
        write(*i1);
    }
 
    // instances
    vector<HepRepInstance*> instanceList = instanceTree->getInstances();
    for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) {
        write(*i2);
    }
    xml->closeTag();
    return true;
}

write() [9/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepPoint *  point )

virtual

Writes a HepRepPoint.

Parameters

point

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 214 of file XMLHepRepWriter.cc.

                                              {
    xml->setAttribute("x", point->getX());
    xml->setAttribute("y", point->getY());
    xml->setAttribute("z", point->getZ());
    if (point->getAttValuesFromNode().size() != 0) {
        xml->openTag(nameSpace, "point");
        write((HepRepAttribute*)point);
        xml->closeTag();
    } else {
        xml->printTag(nameSpace, "point");
    }
    return true;
}

write() [10/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepTreeID *  treeID )

virtual

Writes a HepRepTreeID.

Parameters

treeID

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 159 of file XMLHepRepWriter.cc.

                                                {
    xml->setAttribute("qualifier", treeID->getQualifier());
    xml->setAttribute("name", treeID->getName());
    xml->setAttribute("version", treeID->getVersion());
    xml->printTag(nameSpace, "treeid");
    return true;
}

write() [11/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepType *  type )

virtual

Writes a HepRepType.

Parameters

type	to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 145 of file XMLHepRepWriter.cc.

                                            {
    xml->setAttribute("name", type->getName());
    xml->openTag(nameSpace, "type");
    write((HepRepDefinition*)type);
    write((HepRepAttribute*)type);
    
    vector<HepRepType*> types = type->getTypeList();
    for (vector<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) {
        write(*i);
    }
    xml->closeTag();
    return true;
}

write() [12/13]

bool cheprep::XMLHepRepWriter::write ( HEPREP::HepRepTypeTree *  typeTree )

virtual

Writes a HepRepTypeTree.

Parameters

typeTree

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 131 of file XMLHepRepWriter.cc.

                                                    {
    xml->setAttribute("name", typeTree->getName());
    xml->setAttribute("version", typeTree->getVersion());
    xml->openTag(nameSpace, "typetree");
 
    vector<HepRepType*> types = typeTree->getTypeList();
    for (vector<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) {
        write(*i);
    }
    
    xml->closeTag();
    return true;
}

write() [13/13]

bool cheprep::XMLHepRepWriter::write ( std::vector< std::string >  layerOrder )

virtual

Writes the layerOrder.

Parameters

layerOrder

to be written.

Returns

false in case of a stream problem.

Implements HEPREP::HepRepWriter.

Definition at line 116 of file XMLHepRepWriter.cc.

                                                 {
    string layerOrder = "";
    bool comma = false;
    for (vector<string>::iterator i=layers.begin(); i != layers.end(); i++) {
        if (comma) {
            layerOrder.append(", ");
        }
        layerOrder.append(*i);
        comma = true;
    }
    xml->setAttribute("order", layerOrder);
    xml->printTag(nameSpace, "layer");
    return true;
}

---

The documentation for this class was generated from the following files:

• XMLHepRepWriter.h
• XMLHepRepWriter.cc