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. More...

Detailed Description

Definition at line 38 of file XMLHepRepWriter.h.

Constructor & Destructor Documentation

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

Definition at line 21 of file XMLHepRepWriter.cc.

References NAMESPACE.

        : 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;
        }
    }
}

cheprep::XMLHepRepWriter::~XMLHepRepWriter

(

)

Definition at line 50 of file XMLHepRepWriter.cc.

                                  {
    delete gz;
    delete zip;
}

Member Function Documentation

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 55 of file XMLHepRepWriter.cc.

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

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 60 of file XMLHepRepWriter.cc.

References cheprep::GZIPOutputStream::close(), cheprep::ZipOutputStream::close(), cheprep::ZipOutputStream::closeEntry(), and cheprep::ZipOutputStream::putNextEntry().

                            {
    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;
}

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 79 of file XMLHepRepWriter.cc.

References cheprep::AbstractXMLWriter::closeDoc(), cheprep::ZipOutputStream::closeEntry(), cheprep::AbstractXMLWriter::closeTag(), HEPREP::HepRep::getInstanceTreeList(), HEPREP::HepRep::getLayerOrder(), HEPREP::HepRep::getTypeTreeList(), NAMESPACE, cheprep::AbstractXMLWriter::openDoc(), cheprep::AbstractXMLWriter::openTag(), cheprep::ZipOutputStream::putNextEntry(), and cheprep::AbstractXMLWriter::setAttribute().

Referenced by write().

                                                       {
    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;
}

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 117 of file XMLHepRepWriter.cc.

References cheprep::AbstractXMLWriter::printTag(), and cheprep::AbstractXMLWriter::setAttribute().

                                                 {
    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;
}

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 132 of file XMLHepRepWriter.cc.

References cheprep::AbstractXMLWriter::closeTag(), HEPREP::HepRepTreeID::getName(), HEPREP::HepRepTypeTree::getTypeList(), HEPREP::HepRepTreeID::getVersion(), cheprep::AbstractXMLWriter::openTag(), cheprep::AbstractXMLWriter::setAttribute(), and write().

                                                    {
    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;
}

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 146 of file XMLHepRepWriter.cc.

References cheprep::AbstractXMLWriter::closeTag(), HEPREP::HepRepType::getName(), HEPREP::HepRepType::getTypeList(), cheprep::AbstractXMLWriter::openTag(), cheprep::AbstractXMLWriter::setAttribute(), and write().

                                            {
    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;
}

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 160 of file XMLHepRepWriter.cc.

References HEPREP::HepRepTreeID::getName(), HEPREP::HepRepTreeID::getQualifier(), HEPREP::HepRepTreeID::getVersion(), cheprep::AbstractXMLWriter::printTag(), and cheprep::AbstractXMLWriter::setAttribute().

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

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 168 of file XMLHepRepWriter.cc.

References HEPREP::HepRepAction::getExpression(), HEPREP::HepRepAction::getName(), cheprep::AbstractXMLWriter::printTag(), and cheprep::AbstractXMLWriter::setAttribute().

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

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 175 of file XMLHepRepWriter.cc.

References cheprep::AbstractXMLWriter::closeTag(), HEPREP::HepRepInstanceTree::getInstances(), HEPREP::HepRepInstanceTree::getInstanceTreeList(), HEPREP::HepRepTreeID::getName(), HEPREP::HepRepInstanceTree::getTypeTree(), HEPREP::HepRepTreeID::getVersion(), cheprep::AbstractXMLWriter::openTag(), cheprep::AbstractXMLWriter::setAttribute(), and write().

                                                            {
    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;
}

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 196 of file XMLHepRepWriter.cc.

References cheprep::AbstractXMLWriter::closeTag(), HEPREP::HepRepType::getFullName(), HEPREP::HepRepInstance::getInstances(), HEPREP::HepRepInstance::getPoints(), HEPREP::HepRepInstance::getType(), cheprep::AbstractXMLWriter::openTag(), cheprep::AbstractXMLWriter::setAttribute(), and write().

                                                    {
    // 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;
}

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 215 of file XMLHepRepWriter.cc.

References cheprep::AbstractXMLWriter::closeTag(), HEPREP::HepRepAttribute::getAttValuesFromNode(), HEPREP::HepRepPoint::getX(), HEPREP::HepRepPoint::getY(), HEPREP::HepRepPoint::getZ(), cheprep::AbstractXMLWriter::openTag(), cheprep::AbstractXMLWriter::printTag(), cheprep::AbstractXMLWriter::setAttribute(), and write().

                                              {
    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;
}

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 229 of file XMLHepRepWriter.cc.

References HEPREP::HepRepAttribute::getAttValueFromNode(), HEPREP::HepRepAttribute::getAttValuesFromNode(), and write().

                                                      {
    // 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;
}

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 242 of file XMLHepRepWriter.cc.

References HEPREP::HepRepDefinition::getAttDefsFromNode(), and write().

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

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 250 of file XMLHepRepWriter.cc.

References HEPREP::HepRepAttValue::getAsString(), HEPREP::HepRepAttValue::getBoolean(), HEPREP::HepRepAttValue::getColor(), HEPREP::HepRepAttValue::getDouble(), HEPREP::HepRepAttValue::getInteger(), HEPREP::HepRepAttValue::getLong(), HEPREP::HepRepAttValue::getName(), HEPREP::HepRepAttValue::getString(), HEPREP::HepRepAttValue::getType(), cheprep::AbstractXMLWriter::printTag(), cheprep::AbstractXMLWriter::setAttribute(), and HEPREP::HepRepAttValue::showLabel().

                                                    {
    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;
}

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 279 of file XMLHepRepWriter.cc.

References HEPREP::HepRepAttDef::getCategory(), HEPREP::HepRepAttDef::getDescription(), HEPREP::HepRepAttDef::getExtra(), HEPREP::HepRepAttDef::getName(), cheprep::AbstractXMLWriter::printTag(), and cheprep::AbstractXMLWriter::setAttribute().

                                                {
    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;
}

---

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

• XMLHepRepWriter.h
• XMLHepRepWriter.cc