cheprep::BHepRepWriter Class Reference

#include <BHepRepWriter.h>

Inheritance diagram for cheprep::BHepRepWriter:

Collaboration diagram for cheprep::BHepRepWriter:

Public Member Functions
	BHepRepWriter (std::ostream &os)
virtual	~BHepRepWriter ()
void	close ()
void	openDoc (std::string version="BinaryHepRep/1.0", std::string encoding="UTF-8", bool standalone=false)
void	closeDoc (bool force=false)
void	openTag (std::string name)
void	closeTag ()
void	printTag (std::string name)
void	setAttribute (std::string name, char *value)
void	setAttribute (std::string name, std::string value)
void	setAttribute (std::string name, std::vector< double > value)
void	setAttribute (std::string name, int64 value)
void	setAttribute (std::string name, int value)
void	setAttribute (std::string name, bool value)
void	setAttribute (std::string name, double value)
void	openTag (std::string ns, std::string name)
void	printTag (std::string ns, std::string name)
void	setAttribute (std::string ns, std::string name, std::string value)
void	setAttribute (std::string ns, std::string name, double value)
Public Member Functions inherited from cheprep::AbstractXMLWriter
	AbstractXMLWriter (std::string aDefaultNameSpace)
virtual	~AbstractXMLWriter ()

Private Member Functions
void	writeTag (std::string name, bool content=false)
void	writePoints ()
void	writeStringDefine (std::string s)
void	writeMultiByteInt (unsigned int ui)
void	writeReal (double ui)
void	writeLong (int64 i)
void	writeInt (int i)
void	writeByte (unsigned char b)
void	writeString (std::string s)

Private Attributes
std::ostream &	os
bool	singlePrecision
bool	isBigEndian
std::map< std::string, unsigned int >	stringValues
std::map< std::string, std::string >	stringAttributes
std::map< std::string, std::vector< double > >	colorAttributes
std::map< std::string, int64 >	longAttributes
std::map< std::string, int >	intAttributes
std::map< std::string, bool >	booleanAttributes
std::map< std::string, double >	doubleAttributes
std::vector< double >	points

Static Private Attributes
static const unsigned char	WBXML_VERSION = 0x03
static const unsigned char	UNKNOWN_PID = 0x01
static const unsigned char	UTF8 = 0x6a
static const unsigned char	SWITCH_PAGE = 0x00
static const unsigned char	END = 0x01
static const unsigned char	ENTITY = 0x02
static const unsigned char	STR_I = 0x03
static const unsigned char	LITERAL = 0x04
static const unsigned char	CONTENT = 0x40
static const unsigned char	EXT_I_0 = 0x40
static const unsigned char	EXT_I_1 = 0x41
static const unsigned char	EXT_I_2 = 0x42
static const unsigned char	PI = 0x43
static const unsigned char	LITERAL_C = 0x44
static const unsigned char	ATTRIBUTE = 0x80
static const unsigned char	EXT_T_0 = 0x80
static const unsigned char	EXT_T_1 = 0x81
static const unsigned char	EXT_T_2 = 0x82
static const unsigned char	STR_T = 0x83
static const unsigned char	LITERAL_A = 0x84
static const unsigned char	EXT_0 = 0xC0
static const unsigned char	EXT_1 = 0xC1
static const unsigned char	EXT_2 = 0xC2
static const unsigned char	OPAQUE = 0xC3
static const unsigned char	LITERAL_AC = 0xC4
static const unsigned char	STR_D = EXT_I_0
static const unsigned char	STR_R = EXT_T_0
static std::map< std::string, unsigned char >	tags
static std::map< std::string, unsigned char >	attributes
static std::map< std::string, unsigned char >	values

Additional Inherited Members
Protected Attributes inherited from cheprep::AbstractXMLWriter
std::string	defaultNameSpace

Detailed Description

Definition at line 20 of file BHepRepWriter.h.

Constructor & Destructor Documentation

BHepRepWriter()

cheprep::BHepRepWriter::BHepRepWriter

(

std::ostream &

os

)

Definition at line 21 of file BHepRepWriter.cc.

            : AbstractXMLWriter("heprep"), 
            os(ostrm), 
            singlePrecision(true) {        

        // resolve endiannes        
        union { long l; char c[sizeof (long)]; } u;
        u.l = 1;
        isBigEndian = (u.c[sizeof (long) - 1] == 1);
               
//        std::cout << "Host is " << (isBigEndian ? "Big-Endian" : "Little-Endian") << "." << std::endl;
       
        if (tags.size() <= 0) { 
            // tags
            tags["heprep"]              = 0x05;
            tags["attdef"]              = 0x06;
            tags["attvalue"]            = 0x07;
            tags["instance"]            = 0x08;
            tags["treeid"]              = 0x09;
            tags["action"]              = 0x0a;
            tags["instancetree"]        = 0x0b;
            tags["type"]                = 0x0c;
            tags["typetree"]            = 0x0d;
            tags["layer"]               = 0x0e;
            tags["point"]               = 0x0f;
        }

        if (attributes.size() <= 0) {
            // attribute names
            attributes["version"]               = 0x05;
            attributes["xmlns"]                 = 0x06;
            attributes["xmlns:xsi"]             = 0x07;
            attributes["xsi:schemaLocation"]    = 0x08;
    
            attributes["valueString"]           = 0x10;
            attributes["valueColor"]            = 0x11;
            attributes["valueLong"]             = 0x12;
            attributes["valueInt"]              = 0x13;
            attributes["valueBoolean"]          = 0x14;
            attributes["valueDouble"]           = 0x15;
    
            attributes["name"]                  = 0x20;
            attributes["type"]                  = 0x22;
            attributes["showlabel"]             = 0x23;
            attributes["desc"]                  = 0x24;
            attributes["category"]              = 0x25;
            attributes["extra"]                 = 0x26;
            attributes["x"]                     = 0x27;
            attributes["y"]                     = 0x28;
            attributes["z"]                     = 0x29;
            attributes["qualifier"]             = 0x2a;
            attributes["expression"]            = 0x2b;
            attributes["typetreename"]          = 0x2c;
            attributes["typetreeversion"]       = 0x2d;
            attributes["order"]                 = 0x2e;
            
            // for PI
            attributes["eof"]                   = 0x7f;
        }
        
        if (values.size() <= 0) { 
            // attribute values
            values["drawas"]                     = 0x85;
            values["drawasoptions"]              = 0x86;
            values["visibility"]                 = 0x87;
    
            values["label"]                      = 0x88;
    
            values["fontname"]                   = 0x89;
            values["fontstyle"]                  = 0x8a;
            values["fontsize"]                   = 0x8b;
            values["fontcolor"]                  = 0x8c;
            values["fonthasframe"]               = 0x8d;
            values["fontframecolor"]             = 0x8e;
            values["fontframewidth"]             = 0x8f;
            values["fonthasbanner"]              = 0x90;
            values["fontbannercolor"]            = 0x91;
    
            values["color"]                      = 0x92;
            values["framecolor"]                 = 0x93;
            values["layer"]                      = 0x94;
            values["markname"]                   = 0x95;
            values["marksize"]                   = 0x96;
            values["marksizemultiplier"]         = 0x97;
            values["marktype"]                   = 0x98;
            values["hasframe"]                   = 0x99;
            values["framecolor"]                 = 0x9a;
            values["framewidth"]                 = 0x9b;
    
            values["linestyle"]                  = 0x9c;
            values["linewidth"]                  = 0x9d;
            values["linewidthmultiplier"]        = 0x9e;
            values["linehasarrow"]               = 0x9f;
            
            values["fillcolor"]                  = 0xa0;
            values["filltype"]                   = 0xa1;
            values["fill"]                       = 0xa2;
    
            values["radius"]                     = 0xa3;
            values["phi"]                        = 0xa4;
            values["theta"]                      = 0xa5;
            values["omega"]                      = 0xa6;
            values["radius1"]                    = 0xa7;
            values["radius2"]                    = 0xa8;
            values["radius3"]                    = 0xa9;
            values["curvature"]                  = 0xaa;
            values["flylength"]                  = 0xab;
            values["faces"]                      = 0xac;
    
            values["text"]                       = 0xad;
            values["hpos"]                       = 0xae;
            values["vpos"]                       = 0xaf;
            values["halign"]                     = 0xb0;
            values["valign"]                     = 0xb1;
    
            values["ispickable"]                 = 0xb2;
            values["showparentvalues"]           = 0xb3;
            values["pickparent"]                 = 0xb4;
            
            // attvalue values
            values["false"]         = 0xd0;
            values["true"]          = 0xd1;
            
            values["point"]         = 0xd2;
            values["line"]          = 0xd3;
            values["helix"]         = 0xd4;
            values["polygon"]       = 0xd5;
            values["circle"]        = 0xd6;
            values["curve"]         = 0xd7;
            values["ellipse"]       = 0xd8;
            values["ellipsoid"]     = 0xd9;
            values["prism"]         = 0xda;
            values["cylinder"]      = 0xdb;
            values["ellipseprism"]  = 0xdc;
            values["text"]          = 0xdd;
    
            values["nonzero"]       = 0xde;
            values["evenodd"]       = 0xdf;
            
            values["circle"]        = 0xe0;
            values["box"]           = 0xe1;
            values["uptriangle"]    = 0xe2;
            values["dntriangle"]    = 0xe3;
            values["diamond"]       = 0xe4;
            values["cross"]         = 0xe5;
            values["star"]          = 0xe6;
            values["plus"]          = 0xe7;
            values["hline"]         = 0xe8;
            values["vline"]         = 0xe9;
    
            values["solid"]         = 0xea;
            values["dotted"]        = 0xeb;
            values["dashed"]        = 0xec;
            values["dotdash"]       = 0xed;
            
            values["none"]          = 0xee;
            values["start"]         = 0xef;
            values["end"]           = 0xf0;
            values["both"]          = 0xf1;
    
            values["serif"]         = 0xf2;
            values["sansserif"]     = 0xf3;
            values["monotype"]      = 0xf4;
            values["symbol"]        = 0xf5;
    
            values["plain"]         = 0xf6;
            values["bold"]          = 0xf7;
            values["italic"]        = 0xf8;
    
            values["top"]           = 0xf9;
            values["baseline"]      = 0xfa;
            values["center"]        = 0xfb;
            values["bottom"]        = 0xfc;
    
            values["left"]          = 0xfd;
            values["right"]         = 0xfe;
    
            values["default"]       = 0xff;
        }        
    }

~BHepRepWriter()

cheprep::BHepRepWriter::~BHepRepWriter ( )

virtual

Definition at line 202 of file BHepRepWriter.cc.

                                  {
    }

Member Function Documentation

close()

void cheprep::BHepRepWriter::close ( )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 205 of file BHepRepWriter.cc.

                              {
    }

closeDoc()

void cheprep::BHepRepWriter::closeDoc ( bool  force = false )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 226 of file BHepRepWriter.cc.

                                       {
        writeByte(PI);
        writeByte(attributes["eof"]);
        writeByte(END);
    }

Here is the call graph for this function:

closeTag()

void cheprep::BHepRepWriter::closeTag ( )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 236 of file BHepRepWriter.cc.

                                 {
        writePoints();
        writeByte(END);
    }

Here is the call graph for this function:

openDoc()

void cheprep::BHepRepWriter::openDoc ( std::string  version = "BinaryHepRep/1.0", std::string  encoding = "UTF-8", bool  standalone = false  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 208 of file BHepRepWriter.cc.

                                                                      {
        stringValues.clear();
        
        // header
        writeByte(WBXML_VERSION);
        writeMultiByteInt(UNKNOWN_PID);
        writeMultiByteInt(UTF8);        
        
        version = "BinaryHepRep/1.0"; 
       
        // string table
        writeMultiByteInt(version.length()+1);
        
        // BHepRep Header (as part of the string table)
        writeString(version);
        
    }

Here is the call graph for this function:

openTag() [1/2]

void cheprep::BHepRepWriter::openTag ( std::string  name )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 232 of file BHepRepWriter.cc.

                                              {
        writeTag(name, true);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

openTag() [2/2]

void cheprep::BHepRepWriter::openTag ( std::string  ns, std::string  name  )

inlinevirtual

Implements cheprep::AbstractXMLWriter.

Definition at line 44 of file BHepRepWriter.h.

                                                       {
                openTag(ns == defaultNameSpace ? name : ns.append(":").append(name));
            }

Here is the call graph for this function:

printTag() [1/2]

void cheprep::BHepRepWriter::printTag ( std::string  name )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 241 of file BHepRepWriter.cc.

                                               {
        writeTag(name);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

printTag() [2/2]

void cheprep::BHepRepWriter::printTag ( std::string  ns, std::string  name  )

inlinevirtual

Implements cheprep::AbstractXMLWriter.

Definition at line 47 of file BHepRepWriter.h.

                                                        {
                printTag(ns == defaultNameSpace ? name : ns.append(":").append(name));
            }

Here is the call graph for this function:

setAttribute() [1/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  name, char *  value  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 401 of file BHepRepWriter.cc.

                                                                {
        setAttribute(name, (std::string)value);
    }

Here is the caller graph for this function:

setAttribute() [2/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  name, std::string  value  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 405 of file BHepRepWriter.cc.

                                                                    {
        if (name == "value") name = name.append("String");
                
        // make sure the attribute name is defined
        if (attributes.count(name) <= 0) {
            std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
            return;
        }
                    
        stringAttributes[name] = value;
    }

setAttribute() [3/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  name, std::vector< double >  value  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 417 of file BHepRepWriter.cc.

                                                                            {
        if (name == "value") name = name.append("Color");

        // make sure the attribute name is defined
        if (attributes.count(name) <= 0) {
            std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
            return;
        }
                    
        colorAttributes[name] = value;
    }

setAttribute() [4/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  name, int64  value  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 429 of file BHepRepWriter.cc.

                                                                {
        if (name == "value") name = name.append("Long");

        // make sure the attribute name is defined
        if (attributes.count(name) <= 0) {
            std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
            return;
        }
                    
        longAttributes[name] = value;
    }

setAttribute() [5/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  name, int  value  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 441 of file BHepRepWriter.cc.

                                                              {
        if (name == "value") name = name.append("Int");

        // make sure the attribute name is defined
        if (attributes.count(name) <= 0) {
            std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
            return;
        }
                    
        intAttributes[name] = value;
    }

setAttribute() [6/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  name, bool  value  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 453 of file BHepRepWriter.cc.

                                                               {
        if (name == "value") name = name.append("Boolean");

        // make sure the attribute name is defined
        if (attributes.count(name) <= 0) {
            std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
            return;
        }
                    
        booleanAttributes[name] = value;
    }

setAttribute() [7/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  name, double  value  )

virtual

Implements cheprep::AbstractXMLWriter.

Definition at line 465 of file BHepRepWriter.cc.

                                                                 {
        if (name == "value") name = name.append("Double");

        // make sure the attribute name is defined
        if (attributes.count(name) <= 0) {
            std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
            return;
        }
                    
        doubleAttributes[name] = value;
    }

setAttribute() [8/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  ns, std::string  name, std::string  value  )

inlinevirtual

Implements cheprep::AbstractXMLWriter.

Definition at line 50 of file BHepRepWriter.h.

                                                                             {
                setAttribute(ns.append(":").append(name), value);
            }

Here is the call graph for this function:

setAttribute() [9/9]

void cheprep::BHepRepWriter::setAttribute ( std::string  ns, std::string  name, double  value  )

inlinevirtual

Implements cheprep::AbstractXMLWriter.

Definition at line 53 of file BHepRepWriter.h.

                                                                          {
                setAttribute(ns.append(":").append(name), value);
            }

Here is the call graph for this function:

writeByte()

void cheprep::BHepRepWriter::writeByte ( unsigned char  b )

private

Definition at line 537 of file BHepRepWriter.cc.

                                                 {
        os.put((char)b);
    }

Here is the caller graph for this function:

writeInt()

void cheprep::BHepRepWriter::writeInt ( int  i )

private

Definition at line 529 of file BHepRepWriter.cc.

                                      {
        // write network-order
        os.put((i >> 24) & 0xff);
        os.put((i >> 16) & 0xff);
        os.put((i >>  8) & 0xff);
        os.put((i      ) & 0xff);
    }

Here is the caller graph for this function:

writeLong()

void cheprep::BHepRepWriter::writeLong ( int64  i )

private

Definition at line 517 of file BHepRepWriter.cc.

                                         {        
        // write network-order
        os.put((i >> 56) & 0xff);
        os.put((i >> 48) & 0xff);
        os.put((i >> 40) & 0xff);
        os.put((i >> 32) & 0xff);
        os.put((i >> 24) & 0xff);
        os.put((i >> 16) & 0xff);
        os.put((i >>  8) & 0xff);
        os.put((i      ) & 0xff);
    }    

Here is the caller graph for this function:

writeMultiByteInt()

void cheprep::BHepRepWriter::writeMultiByteInt ( unsigned int  ui )

private

Definition at line 482 of file BHepRepWriter.cc.

                                                         {
        unsigned char buf[5];
        int idx = 0;
        
        do {
            buf[idx++] = (unsigned char) (ui & 0x7f);
            ui = ui >> 7;
        }
        while (ui != 0);

        while (idx > 1) {
            writeByte(buf[--idx] | 0x80);
        }
        writeByte(buf[0]);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

writePoints()

void cheprep::BHepRepWriter::writePoints ( )

private

Definition at line 385 of file BHepRepWriter.cc.

                                    {
        if (points.size() <= 0) return;
        
        writeByte(tags["point"] | CONTENT);                
        writeByte(OPAQUE);
        writeMultiByteInt(points.size()*(singlePrecision ? 4 : 8));
        for (std::vector<double>::iterator i = points.begin(); i != points.end(); ) {
            writeReal(*i++);
            writeReal(*i++);
            writeReal(*i++);
        }
        writeByte(END);
        
        points.clear();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

writeReal()

void cheprep::BHepRepWriter::writeReal ( double  ui )

private

Definition at line 498 of file BHepRepWriter.cc.

                                          {
        if (singlePrecision) {
            union {
                int i;
                float f;
            } u;
            u.f = (float)d;
            writeInt(u.i);
        } else {
            union {
                int64 i;
                double d;
            } u;
            u.d = d;
     
            writeLong(u.i);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

writeString()

void cheprep::BHepRepWriter::writeString ( std::string  s )

private

Definition at line 541 of file BHepRepWriter.cc.

                                               {
        os << s;
        os.put(0);
    }

Here is the caller graph for this function:

writeStringDefine()

void cheprep::BHepRepWriter::writeStringDefine ( std::string  s )

private

Definition at line 477 of file BHepRepWriter.cc.

                                                     {
        writeByte(STR_D);
        writeString(s);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

writeTag()

void cheprep::BHepRepWriter::writeTag ( std::string  name, bool  content = false  )

private

Definition at line 245 of file BHepRepWriter.cc.

                                                                   {
        std::string s = tagName;
        std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);
        
        // find tag
        if (tags.count(s) <= 0) {
            std::cerr << "Cannot find tag '" << s << "' in tags table." << std::endl;
            return;
        }
        
        // write tag
        bool isPoint = (s == "point");
        bool hasAttributes = (stringAttributes.size() > 0) || (doubleAttributes.size() > (unsigned int)(isPoint ? 3 : 0));
        
        if (!hasAttributes && isPoint) {
            // store the point for the future
            points.push_back(doubleAttributes["x"]);
            points.push_back(doubleAttributes["y"]);
            points.push_back(doubleAttributes["z"]);
            return;
        }

        writePoints();
        writeByte(tags[s] | ((hasContent || isPoint) ? CONTENT : 0x00) | (hasAttributes ? ATTRIBUTE : 0x00));        
            
        // write attributes
        if (hasAttributes) {
            // write string attributes
            for (std::map<std::string,std::string>::iterator i = stringAttributes.begin(); i != stringAttributes.end(); i++) {
                std::string name = i->first;
                std::string value = i->second;

                // write ATTRSTART
                writeByte(attributes[name]);
                std::string v = value;
                std::transform(v.begin(), v.end(), v.begin(), (int(*)(int)) tolower);
                if (values.count(v) > 0) {
                    // write ATTRVALUE
                    writeByte(values[v]);
                } else {
                    if (stringValues.count(value) <= 0) {
                        // define this new string
                        writeStringDefine(value);
                        int index = stringValues.size();
                        stringValues[value] = index;
                    } else {
                        // write string ref
                        writeByte(STR_R);
                        writeMultiByteInt(stringValues[value]);    
                    }
                }
            }
            stringAttributes.clear();            

            // write color attributes
            for (std::map<std::string,std::vector<double> >::iterator i = colorAttributes.begin(); i != colorAttributes.end(); i++) {
                std::string name = i->first;
                std::vector<double> value = i->second;
                // write ATTRSTART
                writeByte(attributes[name]);
                // write OPAQUE
                writeByte(OPAQUE);
                writeMultiByteInt(value.size());
                writeByte((int)(value[0] * 0xff) & 0xff);
                writeByte((int)(value[1] * 0xff) & 0xff);
                writeByte((int)(value[2] * 0xff) & 0xff);
                if (value.size() > 3) writeByte((int)(value[3] * 0xff) & 0xff);
            }
            colorAttributes.clear();
            
            // write long attributes
            for (std::map<std::string,int64>::iterator i = longAttributes.begin(); i != longAttributes.end(); i++) {
                std::string name = i->first;
                int64 value = i->second;
                 // write ATTRSTART
                writeByte(attributes[name]);
                // write OPAQUE
                writeByte(OPAQUE);
                writeMultiByteInt(8);
                writeLong(value);
            }
            longAttributes.clear();
            
            // write int attributes
            for (std::map<std::string,int>::iterator i = intAttributes.begin(); i != intAttributes.end(); i++) {
                std::string name = i->first;
                int value = i->second;
                // write ATTRSTART
                writeByte(attributes[name]);
                // write OPAQUE
                writeByte(OPAQUE);
                writeMultiByteInt(4);
                writeInt(value);
            }
            intAttributes.clear();
            
            // write boolean attributes
            for (std::map<std::string,bool>::iterator i = booleanAttributes.begin(); i != booleanAttributes.end(); i++) {
                std::string name = i->first;
                bool value = i->second;
                // write ATTRSTART
                writeByte(attributes[name]);
                // write ATTRVALUE
                writeByte(value ? values["true"] : values["false"]);
            }
            booleanAttributes.clear();
            
            // write double attributes
            for (std::map<std::string,double>::iterator i = doubleAttributes.begin(); i != doubleAttributes.end(); i++) {
                std::string name = i->first;
                double value = i->second;
                if (!isPoint && (name != "x") && (name != "y") && (name != "z")) {
                    // write ATTRSTART
                    writeByte(attributes[name]);
                    // write OPAQUE
                    writeByte(OPAQUE);
                    writeMultiByteInt(singlePrecision ? 4 : 8);
                    writeReal(value);
                }        
            }
            doubleAttributes.clear();
            
            // end of attributes
            writeByte(END);          
        }
        
        if (s == "point") {
            writeByte(OPAQUE);
            writeMultiByteInt(singlePrecision ?  12 : 24);
            writeReal(doubleAttributes["x"]);
            writeReal(doubleAttributes["y"]);
            writeReal(doubleAttributes["z"]);
        }
        
        if (isPoint && !hasContent) {
            // end this tag
            writeByte(END);
        }    
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

ATTRIBUTE

const unsigned char cheprep::BHepRepWriter::ATTRIBUTE = 0x80

staticprivate

Definition at line 76 of file BHepRepWriter.h.

attributes

std::map< std::string, unsigned char > cheprep::BHepRepWriter::attributes

staticprivate

Definition at line 95 of file BHepRepWriter.h.

booleanAttributes

std::map<std::string, bool> cheprep::BHepRepWriter::booleanAttributes

private

Definition at line 111 of file BHepRepWriter.h.

colorAttributes

std::map<std::string, std::vector<double> > cheprep::BHepRepWriter::colorAttributes

private

Definition at line 108 of file BHepRepWriter.h.

CONTENT

const unsigned char cheprep::BHepRepWriter::CONTENT = 0x40

staticprivate

Definition at line 69 of file BHepRepWriter.h.

doubleAttributes

std::map<std::string, double> cheprep::BHepRepWriter::doubleAttributes

private

Definition at line 112 of file BHepRepWriter.h.

END

const unsigned char cheprep::BHepRepWriter::END = 0x01

staticprivate

Definition at line 64 of file BHepRepWriter.h.

ENTITY

const unsigned char cheprep::BHepRepWriter::ENTITY = 0x02

staticprivate

Definition at line 65 of file BHepRepWriter.h.

EXT_0

const unsigned char cheprep::BHepRepWriter::EXT_0 = 0xC0

staticprivate

Definition at line 83 of file BHepRepWriter.h.

EXT_1

const unsigned char cheprep::BHepRepWriter::EXT_1 = 0xC1

staticprivate

Definition at line 84 of file BHepRepWriter.h.

EXT_2

const unsigned char cheprep::BHepRepWriter::EXT_2 = 0xC2

staticprivate

Definition at line 85 of file BHepRepWriter.h.

EXT_I_0

const unsigned char cheprep::BHepRepWriter::EXT_I_0 = 0x40

staticprivate

Definition at line 70 of file BHepRepWriter.h.

EXT_I_1

const unsigned char cheprep::BHepRepWriter::EXT_I_1 = 0x41

staticprivate

Definition at line 71 of file BHepRepWriter.h.

EXT_I_2

const unsigned char cheprep::BHepRepWriter::EXT_I_2 = 0x42

staticprivate

Definition at line 72 of file BHepRepWriter.h.

EXT_T_0

const unsigned char cheprep::BHepRepWriter::EXT_T_0 = 0x80

staticprivate

Definition at line 77 of file BHepRepWriter.h.

EXT_T_1

const unsigned char cheprep::BHepRepWriter::EXT_T_1 = 0x81

staticprivate

Definition at line 78 of file BHepRepWriter.h.

EXT_T_2

const unsigned char cheprep::BHepRepWriter::EXT_T_2 = 0x82

staticprivate

Definition at line 79 of file BHepRepWriter.h.

intAttributes

std::map<std::string, int> cheprep::BHepRepWriter::intAttributes

private

Definition at line 110 of file BHepRepWriter.h.

isBigEndian

bool cheprep::BHepRepWriter::isBigEndian

private

Definition at line 101 of file BHepRepWriter.h.

LITERAL

const unsigned char cheprep::BHepRepWriter::LITERAL = 0x04

staticprivate

Definition at line 67 of file BHepRepWriter.h.

LITERAL_A

const unsigned char cheprep::BHepRepWriter::LITERAL_A = 0x84

staticprivate

Definition at line 81 of file BHepRepWriter.h.

LITERAL_AC

const unsigned char cheprep::BHepRepWriter::LITERAL_AC = 0xC4

staticprivate

Definition at line 87 of file BHepRepWriter.h.

LITERAL_C

const unsigned char cheprep::BHepRepWriter::LITERAL_C = 0x44

staticprivate

Definition at line 74 of file BHepRepWriter.h.

longAttributes

std::map<std::string, int64> cheprep::BHepRepWriter::longAttributes

private

Definition at line 109 of file BHepRepWriter.h.

OPAQUE

const unsigned char cheprep::BHepRepWriter::OPAQUE = 0xC3

staticprivate

Definition at line 86 of file BHepRepWriter.h.

os

std::ostream& cheprep::BHepRepWriter::os

private

Definition at line 99 of file BHepRepWriter.h.

PI

const unsigned char cheprep::BHepRepWriter::PI = 0x43

staticprivate

Definition at line 73 of file BHepRepWriter.h.

points

std::vector<double> cheprep::BHepRepWriter::points

private

Definition at line 115 of file BHepRepWriter.h.

singlePrecision

bool cheprep::BHepRepWriter::singlePrecision

private

Definition at line 100 of file BHepRepWriter.h.

STR_D

const unsigned char cheprep::BHepRepWriter::STR_D = EXT_I_0

staticprivate

Definition at line 90 of file BHepRepWriter.h.

STR_I

const unsigned char cheprep::BHepRepWriter::STR_I = 0x03

staticprivate

Definition at line 66 of file BHepRepWriter.h.

STR_R

const unsigned char cheprep::BHepRepWriter::STR_R = EXT_T_0

staticprivate

Definition at line 91 of file BHepRepWriter.h.

STR_T

const unsigned char cheprep::BHepRepWriter::STR_T = 0x83

staticprivate

Definition at line 80 of file BHepRepWriter.h.

stringAttributes

std::map<std::string, std::string> cheprep::BHepRepWriter::stringAttributes

private

Definition at line 107 of file BHepRepWriter.h.

stringValues

std::map<std::string, unsigned int> cheprep::BHepRepWriter::stringValues

private

Definition at line 104 of file BHepRepWriter.h.

SWITCH_PAGE

const unsigned char cheprep::BHepRepWriter::SWITCH_PAGE = 0x00

staticprivate

Definition at line 63 of file BHepRepWriter.h.

tags

std::map< std::string, unsigned char > cheprep::BHepRepWriter::tags

staticprivate

Definition at line 94 of file BHepRepWriter.h.

UNKNOWN_PID

const unsigned char cheprep::BHepRepWriter::UNKNOWN_PID = 0x01

staticprivate

Definition at line 59 of file BHepRepWriter.h.

UTF8

const unsigned char cheprep::BHepRepWriter::UTF8 = 0x6a

staticprivate

Definition at line 60 of file BHepRepWriter.h.

values

std::map< std::string, unsigned char > cheprep::BHepRepWriter::values

staticprivate

Definition at line 96 of file BHepRepWriter.h.

WBXML_VERSION

const unsigned char cheprep::BHepRepWriter::WBXML_VERSION = 0x03

staticprivate

Definition at line 58 of file BHepRepWriter.h.

---

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

• BHepRepWriter.h
• BHepRepWriter.cc