doxygen_doc/html/xmlfile_8h_source.html

#ifndef XMLFILE_H

#define XMLFILE_H


#include <string>

#include <iostream>

#include <list>

#include <vector>

#include <set>

#include <stack>


//#define RAPIDXML_NO_EXCEPTIONS

#include "rapidxml/rapidxml.hpp"


#ifdef ENABLE_MPI

#include <mpi.h>

#endif


//+XMLfile======================================================================

class XMLfile

{

    //typedef rapidxml::xml_node<> t_XMLnode;

    typedef rapidxml::xml_base<> t_XMLnode;

    typedef rapidxml::xml_node<> t_XMLelement;

    typedef rapidxml::xml_attribute<> t_XMLattribute;

    typedef rapidxml::xml_document<> t_XMLdocument;


public:

    static const char *const includeattrtag;

    static const char *const queryattrtag;


    class Query;

    //class Query::const_iterator; forward declaration not possible...


//+XMLfile::Node----------------------------------------------------------------

    class Node

    {

    friend class Query;

    friend class XMLfile;

    // using member function friends is more specific about where private access happens, but is difficult to handle for a one-pass-compiler...

    //friend Node Query::operator [](unsigned long idx) const;

    //friend Node Query::const_iterator::operator *() const;

    //friend bool changecurrentnode(const Query::const_iterator& pos);

    //friend unsigned long changecurrentnode(const std::string& nodepath);

    //friend void expandincludes();

    //friend unsigned long query(std::list<Node>& nodeselection, const char* querystr, Node startnode) const;

    //friend bool initfile_local(const std::string& filepath);

    //friend void initstring_local(const char* xmlstring);


    public:

        enum NodeType { Unknown_Node=-1,

                         Invalid_Node=0,

                         ELEMENT_Node=1,

                         ATTRIBUTE_Node=2,

                         TEXT_Node=3,

                         CDATA_SECTION_Node=4,

                         ENTITY_REFERENCE_Node=5,

                         ENTITY_Node=6,

                         PROCESSING_INSTRUCTION_Node=7,

                         COMMENT_Node=8,

                         DOCUMENT_Node=9,

                         DOCUMENT_TYPE_Node=10,

                         DOCUMENT_FRAGMENT_Node=11,

                         NOTATION_Node=12 };


        Node()

            : m_xmlnode(NULL), m_nodepath(std::string()), m_type(Unknown_Node)

            {}


        Node(const Node& n)

            : m_xmlnode(n.m_xmlnode), m_nodepath(n.m_nodepath), m_type(n.m_type)

            {}


        const std::string& nodepath() const

            { return m_nodepath; }


        std::string name() const

            { return (m_xmlnode) ? std::string(m_xmlnode->name()) : std::string(); }


        void invalidate()

            { m_xmlnode=NULL; m_nodepath=std::string(); }


        NodeType type() const

            { return m_type; }


        bool isRootNode() const

            { if(m_xmlnode && ! m_xmlnode->parent()) return true; else return false; }

        bool isLeafNode() const;


        template<typename T> bool getValue(T& value) const;


        std::string value_string(std::string defaultvalue=std::string()) const;

        int value_int(int defaultvalue=0) const;

        long value_long(long defaultvalue=0) const;

        float value_float(float defaultvalue=0.) const;

        double value_double(double defaultvalue=0.) const;

        bool value_bool(bool defaultvalue=false) const;


        Node& operator =(const Node& n)

            { m_xmlnode=n.m_xmlnode; m_nodepath=n.m_nodepath; return *this; }

        template<typename T> operator T() const

            { T value; getValue(value); return value; }

        operator bool() const

            { return m_xmlnode!=NULL && m_type!=Invalid_Node; }


        void printXML(std::ostream& ostrm=std::cout) const;

        void print(std::ostream& ostrm=std::cout) const;


        Node& operator=(Node& node){

            m_xmlnode = node.m_xmlnode;

            m_nodepath = node.m_nodepath;

            m_type = node.m_type;

            return *this;

        }

    private:

        Node(const t_XMLnode* xmlnode, std::string nodepath=std::string())

            : m_xmlnode(xmlnode), m_nodepath(nodepath), m_type(Unknown_Node)

            { if(!xmlnode) m_type=Invalid_Node; }

        Node(const t_XMLelement* xmlelement, std::string nodepath=std::string());

        Node(const t_XMLattribute* xmlattribute, std::string nodepath=std::string())

            : m_xmlnode(xmlattribute), m_nodepath(nodepath), m_type(ATTRIBUTE_Node)

            { if(!xmlattribute) m_type=Invalid_Node; }

        /* rapidxml::xml_document is derived from rapidxml::xml_node => t_XMLelement* constructor will handle this

        Node(const t_XMLdocument* xmldocument, std::string nodepath=std::string())

            : m_xmlnode(xmldocument), m_nodepath(nodepath), m_type(DOCUMENT_Node)

            { if(!xmldocument) m_type=Invalid_Node; }

        */


        const t_XMLnode*    m_xmlnode;

        std::string m_nodepath;

        NodeType    m_type;

    };

//-XMLfile::Node----------------------------------------------------------------


//+XMLfile::Query---------------------------------------------------------------

    class Query

    {

    friend class XMLfile;

    //friend Query XMLfile::query(const char* querystr) const;


    public:


//+XMLfile::Query::const_iterator...............................................

        class const_iterator

        {

        friend class Query;


        public:

            const_iterator()

                : m_query(NULL), m_nodesidx(0) {}

            long index() const { return m_nodesidx; }

            operator bool() const

                { return m_query!=NULL && m_nodesidx>=0 && m_nodesidx<long(m_query->card()); }

            const_iterator& operator ++()

                { if(m_nodesidx<long(m_query->card())) ++m_nodesidx; return *this; }

            const_iterator operator ++(int)

                { if(m_nodesidx<long(m_query->card())) m_nodesidx++; return *this; }

            const_iterator& operator --() // prefix decrement

                { if(m_nodesidx>=0) --m_nodesidx; return *this; }

            const_iterator operator --(int)     // postfix decrement

                { if(m_nodesidx>=0) m_nodesidx--; return *this; }

            Node operator *() const

                { if(*this) return (*m_query)[m_nodesidx]; else return Node(); }


        private:

            const Query* m_query;

            long m_nodesidx;


            const_iterator(const Query* query, long idx)

                : m_query(query), m_nodesidx(idx) {}

        };

//-XMLfile::Query::const_iterator...............................................


        Query() : m_xmlfile(NULL), m_nodes()

            {}

        Query(const Query& q) : m_xmlfile(q.m_xmlfile), m_nodes(q.m_nodes)

            { xmlfile_register(); }

        ~Query()

            { xmlfile_unregister(); }


        unsigned long card() const { return m_nodes.size(); }

        bool empty() const

            { return card()==0; }

        void invalidate()

            { xmlfile_unregister(); m_xmlfile=NULL; m_nodes.clear(); }

        Node front() const

            { return (*this)[0]; }


        Query& operator =(const Query& q);

        operator unsigned long() const

            { return card(); }

        operator bool() const

            { return m_xmlfile!=NULL; }

        Node operator [](unsigned long idx) const

            { if(idx<m_nodes.size()) return Node(m_nodes[idx]); else return Node(); }


        const_iterator begin() const

            { return const_iterator(this,0); }

        const_iterator rbegin() const

            { return const_iterator(this,m_nodes.size()-1); }

        bool end() const

            { return false; }

        /*

        bool rend() const

            { return false; }

        */


        template<typename T> unsigned long getNodeValue(T& value) const;

        std::string getNodeValue_string(const std::string defaultvalue=std::string()) const

            { std::string value(defaultvalue); getNodeValue(value); return value; }

        int getNodeValue_int(int defaultvalue=0) const

            { int value=defaultvalue; getNodeValue(value); return value; }

        long getNodeValue_long(long defaultvalue=0) const

            { long value=defaultvalue; getNodeValue(value); return value; }

        float getNodeValue_float(float defaultvalue=0.) const

            { float value=defaultvalue; getNodeValue(value); return value; }

        double getNodeValue_double(double defaultvalue=0.) const

            { double value=defaultvalue; getNodeValue(value); return value; }

        bool getNodeValue_bool(bool defaultvalue=false) const

            { bool value=defaultvalue; getNodeValue(value); return value; }


        void printXML(std::ostream& ostrm=std::cout) const;

        void print(std::ostream& ostrm=std::cout) const;


    private:

        const XMLfile*  m_xmlfile;

        std::vector<Node> m_nodes;    // nodes within the actual query set


        Query(const XMLfile* xmlfile)

            : m_xmlfile(xmlfile)

            { m_nodes.clear(); }


        void xmlfile_register()

            { if(m_xmlfile) m_xmlfile->registerQuery(this); }

        void xmlfile_unregister()

            { if(m_xmlfile) m_xmlfile->unregisterQuery(this); }

    };

//-XMLfile::Query---------------------------------------------------------------


        friend void Query::xmlfile_register();

        friend void Query::xmlfile_unregister();


    XMLfile();

    virtual ~XMLfile() { clear(); }


    XMLfile(const std::string& filepath);


    bool initfile(const std::string& filepath);


    void initstring(const char* xmlstring);


    const std::string getDir() const { return m_filedir; }

    const std::string getFilename() const { return m_filename; }


    long changecurrentnode(const std::string& nodepath=std::string("/"));

    bool changecurrentnode(const Query::const_iterator& pos);

    std::string getcurrentnodepath() const { return m_currentnode.nodepath(); }


    template<typename T> unsigned long getNodeValue(const std::string& nodepath, T& value) const

        //{ Query q=query(nodepath.c_str()); if(!q.empty()) q.front().getValue(value); return q.card(); }

        { return query(nodepath).getNodeValue(value); }

    template<typename T> unsigned long getNodeValue(const char* nodepath, T& value) const

        { return getNodeValue(std::string(nodepath),value); }

    std::string getNodeValue_string(const std::string& nodepath, const std::string defaultvalue=std::string()) const

        //{ std::string value(defaultvalue); getNodeValue(nodepath,value); return value; }

        { return query(nodepath).getNodeValue_string(defaultvalue); }

    std::string getNodeValue_string(const char* nodepath, std::string defaultvalue=std::string()) const

        { return getNodeValue_string(std::string(nodepath),defaultvalue); }

    int getNodeValue_int(const std::string& nodepath, int defaultvalue=0) const

        //{ int value=defaultvalue; getNodeValue(nodepath,value); return value; }

        { return query(nodepath).getNodeValue_int(defaultvalue); }

    int getNodeValue_int(const char* nodepath, int defaultvalue=0) const

        { return getNodeValue_int(std::string(nodepath),defaultvalue); }

    long getNodeValue_long(const std::string& nodepath, long defaultvalue=0) const

        //{ long value=defaultvalue; getNodeValue(nodepath,value); return value; }

        { return query(nodepath.c_str()).getNodeValue_long(defaultvalue); }

    long getNodeValue_long(const char* nodepath, long defaultvalue=0) const

        { return getNodeValue_long(std::string(nodepath),defaultvalue); }

    float getNodeValue_float(const std::string& nodepath, float defaultvalue=0.) const

        //{ float value=defaultvalue; getNodeValue(nodepath,value); return value; }

        { return query(nodepath).getNodeValue_float(defaultvalue); }

    float getNodeValue_float(const char* nodepath, float defaultvalue=0.) const

        { return getNodeValue_float(std::string(nodepath),defaultvalue); }

    double getNodeValue_double(const std::string& nodepath, double defaultvalue=0.) const

        //{ double value=defaultvalue; getNodeValue(nodepath,value); return value; }

        { return query(nodepath).getNodeValue_double(defaultvalue); }

    double getNodeValue_double(const char* nodepath, double defaultvalue=0.) const

        { return getNodeValue_double(std::string(nodepath),defaultvalue); }

    bool getNodeValue_bool(const std::string& nodepath, bool defaultvalue=false) const

        //{ bool value=defaultvalue; getNodeValue(nodepath,value); return value; }

        { return query(nodepath).getNodeValue_bool(defaultvalue); }

    bool getNodeValue_bool(const char* nodepath, bool defaultvalue=false) const

        { return getNodeValue_bool(std::string(nodepath),defaultvalue); }


    void printXML(std::ostream& ostrm=std::cout) const;

    void print(std::ostream& ostrm=std::cout) const;

    void save(std::string filepath=std::string());


    Query query(const std::string& querystr) const;


    operator std::string() const;


    size_t numqueries() const

        { return m_queries.size(); }


#ifdef ENABLE_MPI

    void setMPIdefaults(int mpirootrank=0, MPI_Comm mpicomm=MPI_COMM_WORLD);

#endif


//protected:

private:

    std::string m_filedir;

    std::string m_filename;

    t_XMLdocument m_xmldoc;

    Node m_currentnode;

    mutable std::set<Query*> m_queries;

    //std::stack<Node> m_lastnodes;


    void clear();

    bool initfile_local(const std::string& filepath);

    void initstring_local(const char* xmlstring);

    void expandincludes();

    unsigned long query(std::list<Node>& nodeselection, const std::string& querystring, Node startnode=Node()) const;

    void insertcloneelement(const t_XMLelement* src, t_XMLelement* dest_after);


    void registerQuery(Query* q) const

        { if(q) m_queries.insert(q); }

    void unregisterQuery(Query* q) const

        { m_queries.erase(q); }

    void invalidateQueries()

    { for(std::set<Query*>::iterator pos=m_queries.begin();pos!=m_queries.end();++pos) (*pos)->invalidate(); m_queries.clear(); }


#ifdef ENABLE_MPI

    int m_mpi_rootrank;

    MPI_Comm m_mpi_comm;

    int m_mpi_myrank;

    //bool m_mpi_isroot;


    bool distributeXMLstring();

#endif


};

//-XMLfile======================================================================


inline std::ostream& operator << (std::ostream& ostrm, const XMLfile::Node& xmlnode)

{

    xmlnode.printXML(ostrm);

    return ostrm;

}


inline std::ostream& operator << (std::ostream& ostrm, const XMLfile::Query& xmlquery)

{

    xmlquery.printXML(ostrm);

    return ostrm;

}


inline std::ostream& operator << (std::ostream& ostrm, const XMLfile& xmlfile)

{

    xmlfile.printXML(ostrm);

    return ostrm;

}


/*

// explicit instantiation

template bool XMLfile::Node::getValue<std::string>(std::string& value)const;

template bool XMLfile::Node::getValue<int>(int& value)const;

template bool XMLfile::Node::getValue<long>(long& value)const;

template bool XMLfile::Node::getValue<float>(float& value)const;

template bool XMLfile::Node::getValue<double>(double& value)const;

template bool XMLfile::Node::getValue<bool>(bool& value)const;

*/


#endif

XMLfile::Node
Definition: xmlfile.h:64

XMLfile::Node::print
void print(std::ostream &ostrm=std::cout) const
print data to stream print the node data
Definition: xmlfile.cpp:689

XMLfile::Node::invalidate
void invalidate()
invalidate the node set the internal state to invalid
Definition: xmlfile.h:123

XMLfile::Node::isRootNode
bool isRootNode() const
check, if node is root node return true, if node is a valid root node - false otherwise
Definition: xmlfile.h:135

XMLfile::Node::nodepath
const std::string & nodepath() const
get nodepath returns the full path of the node
Definition: xmlfile.h:113

XMLfile::Node::type
NodeType type() const
get node type determine the node type (enumeration)
Definition: xmlfile.h:129

XMLfile::Node::value_float
float value_float(float defaultvalue=0.) const
get the node float value returns the node value as float value or default value, if node is invalid
Definition: xmlfile.cpp:644

XMLfile::Node::printXML
void printXML(std::ostream &ostrm=std::cout) const
print XML data to stream print the node content using XML syntax
Definition: xmlfile.cpp:674

XMLfile::Node::value_int
int value_int(int defaultvalue=0) const
get the node int value returns the node value as int value or default value, if node is invalid
Definition: xmlfile.cpp:624

XMLfile::Node::value_string
std::string value_string(std::string defaultvalue=std::string()) const
get the node string value returns the node value as string value or default value,...
Definition: xmlfile.cpp:614

XMLfile::Node::Node
Node()
XMLfile::Node constructor sets up an invalid node.
Definition: xmlfile.h:99

XMLfile::Node::Node
Node(const Node &n)
XMLfile::Node copy constructor duplicate a node.
Definition: xmlfile.h:106

XMLfile::Node::isLeafNode
bool isLeafNode() const
check, if node is leaf node return true, if node is a valid leaf node - false otherwise
Definition: xmlfile.cpp:524

XMLfile::Node::NodeType
NodeType
Node types enumeration associates a number to each XML node type.
Definition: xmlfile.h:82

XMLfile::Node::value_double
double value_double(double defaultvalue=0.) const
get the node double value returns the node value as double value or default value,...
Definition: xmlfile.cpp:654

XMLfile::Node::operator=
Node & operator=(const Node &n)
assignment operator copy/duplicate other node content to node
Definition: xmlfile.h:183

XMLfile::Node::name
std::string name() const
get node name returns the name of the node, if node is valid - otherwise an empty string
Definition: xmlfile.h:118

XMLfile::Node::value_long
long value_long(long defaultvalue=0) const
get the node long value returns the node value as long value or default value, if node is invalid
Definition: xmlfile.cpp:634

XMLfile::Node::value_bool
bool value_bool(bool defaultvalue=false) const
get the node bool value returns the node value as bool value or default value, if node is invalid
Definition: xmlfile.cpp:664

XMLfile::Node::getValue
bool getValue(T &value) const
get the node value returns the node value converted to a given type
Definition: xmlfile.cpp:532

XMLfile::Query::const_iterator
Definition: xmlfile.h:240

XMLfile::Query::const_iterator::operator--
const_iterator & operator--()
prefix decrement operator decrement the index
Definition: xmlfile.h:266

XMLfile::Query::const_iterator::operator*
Node operator*() const
access operator return the node, the iterator (index) actually points to or an invalid Node,...
Definition: xmlfile.h:276

XMLfile::Query::const_iterator::const_iterator
const_iterator()
XMLfile::Query::const_iterator constructor sets up an invalid iterator.
Definition: xmlfile.h:246

XMLfile::Query::const_iterator::operator++
const_iterator & operator++()
prefix increment operator put the index to the next position
Definition: xmlfile.h:256

XMLfile::Query
Definition: xmlfile.h:232

XMLfile::Query::operator[]
Node operator[](unsigned long idx) const
indexing operator return the Node within the query at given index, or empty node, if query or index i...
Definition: xmlfile.h:338

XMLfile::Query::invalidate
void invalidate()
invalidate query unregister from XMLfile and invalidate the query
Definition: xmlfile.h:313

XMLfile::Query::getNodeValue_double
double getNodeValue_double(double defaultvalue=0.) const
get node value as double get the node content and convert it to a double
Definition: xmlfile.h:399

XMLfile::Query::getNodeValue_bool
bool getNodeValue_bool(bool defaultvalue=false) const
get node value as bool get the node content and convert it to a bool
Definition: xmlfile.h:405

XMLfile::Query::Query
Query()
XMLfile::Query constructor sets up an invalid query.
Definition: xmlfile.h:290

XMLfile::Query::getNodeValue_long
long getNodeValue_long(long defaultvalue=0) const
get node value as long get the node content and convert it to a long
Definition: xmlfile.h:387

XMLfile::Query::begin
const_iterator begin() const
get starting iterator return an iterator to the first node
Definition: xmlfile.h:344

XMLfile::Query::printXML
void printXML(std::ostream &ostrm=std::cout) const
print XML data to stream print the query content using XML syntax
Definition: xmlfile.cpp:762

XMLfile::Query::getNodeValue_int
int getNodeValue_int(int defaultvalue=0) const
get node value as int get the node content and convert it to an int
Definition: xmlfile.h:381

XMLfile::Query::print
void print(std::ostream &ostrm=std::cout) const
print data to stream print the query content
Definition: xmlfile.cpp:768

XMLfile::Query::end
bool end() const
get (dummy) iteration end for comparison return false (as dummy) to enable e.g. for(it=query....
Definition: xmlfile.h:355

XMLfile::Query::rbegin
const_iterator rbegin() const
get reverse starting iterator return an iterator to the last node
Definition: xmlfile.h:349

XMLfile::Query::card
unsigned long card() const
get cardinality of query set return the size of the query set
Definition: xmlfile.h:305

XMLfile::Query::empty
bool empty() const
check ,if query set is empty return true if the query set is empty
Definition: xmlfile.h:309

XMLfile::Query::getNodeValue_float
float getNodeValue_float(float defaultvalue=0.) const
get node value as float get the node content and convert it to a float
Definition: xmlfile.h:393

XMLfile::Query::front
Node front() const
get first query entry return the first Node of the query set (invalid Node, if there's none)
Definition: xmlfile.h:318

XMLfile::Query::getNodeValue_string
std::string getNodeValue_string(const std::string defaultvalue=std::string()) const
get node value as string get the node content
Definition: xmlfile.h:375

XMLfile::Query::Query
Query(const Query &q)
copy constructor duplicate a given query and register the new created one at the XMLfile
Definition: xmlfile.h:295

XMLfile::Query::~Query
~Query()
XMLfile::Query destructor unregister the query.
Definition: xmlfile.h:299

XMLfile::Query::operator=
Query & operator=(const Query &q)
assignment operator copy/duplicate other query content to query
Definition: xmlfile.cpp:738

XMLfile::Query::getNodeValue
unsigned long getNodeValue(T &value) const
get node value get the node content and convert it to a given type
Definition: xmlfile.cpp:747

XMLfile
XML file abstraction.
Definition: xmlfile.h:47

XMLfile::query
Query query(const std::string &querystr) const
perform a query return a query to a given query expression

XMLfile::printXML
void printXML(std::ostream &ostrm=std::cout) const
print node content as XML print node content to stream using XML
Definition: xmlfile.cpp:159

XMLfile::getNodeValue_bool
bool getNodeValue_bool(const std::string &nodepath, bool defaultvalue=false) const
get node value as bool get the node content and convert it to a bool (an alternative of using <tag>tr...
Definition: xmlfile.h:575

XMLfile::getNodeValue
unsigned long getNodeValue(const char *nodepath, T &value) const
get node value get the node content and convert it to a given type
Definition: xmlfile.h:492

XMLfile::print
void print(std::ostream &ostrm=std::cout) const
print node content print node content and debug information to stream
Definition: xmlfile.cpp:164

XMLfile::changecurrentnode
long changecurrentnode(const std::string &nodepath=std::string("/"))
set current node set a node, relative queries start with

XMLfile::save
void save(std::string filepath=std::string())
save save node content as XML-file
Definition: xmlfile.cpp:113

XMLfile::getNodeValue_long
long getNodeValue_long(const char *nodepath, long defaultvalue=0) const
get node value as long get the node content and convert it to a long
Definition: xmlfile.h:537

XMLfile::getNodeValue_int
int getNodeValue_int(const std::string &nodepath, int defaultvalue=0) const
get node value as int get the node content and convert it to an integer
Definition: xmlfile.h:514

XMLfile::getNodeValue_bool
bool getNodeValue_bool(const char *nodepath, bool defaultvalue=false) const
get node value as bool get the node content and convert it to a bool
Definition: xmlfile.h:583

XMLfile::getNodeValue_string
std::string getNodeValue_string(const std::string &nodepath, const std::string defaultvalue=std::string()) const
get node value as string get the node content
Definition: xmlfile.h:499

XMLfile::getNodeValue_long
long getNodeValue_long(const std::string &nodepath, long defaultvalue=0) const
get node value as long get the node content and convert it to a long
Definition: xmlfile.h:529

XMLfile::getFilename
const std::string getFilename() const
get XML filename if instantiated with a XML-file, return the filename (without directory part of path...
Definition: xmlfile.h:462

XMLfile::getNodeValue_float
float getNodeValue_float(const char *nodepath, float defaultvalue=0.) const
get node value as float get the node content and convert it to a float
Definition: xmlfile.h:552

XMLfile::~XMLfile
virtual ~XMLfile()
XMLfile default destructor.
Definition: xmlfile.h:438

XMLfile::initfile
bool initfile(const std::string &filepath)
initialize with XML-file instantiating with XML file
Definition: xmlfile.cpp:54

XMLfile::getNodeValue_double
double getNodeValue_double(const char *nodepath, double defaultvalue=0.) const
get node value as double get the node content and convert it to a double
Definition: xmlfile.h:567

XMLfile::getNodeValue
unsigned long getNodeValue(const std::string &nodepath, T &value) const
get node value get the node content and convert it to a given type
Definition: xmlfile.h:484

XMLfile::getNodeValue_float
float getNodeValue_float(const std::string &nodepath, float defaultvalue=0.) const
get node value as float get the node content and convert it to a float
Definition: xmlfile.h:544

XMLfile::getNodeValue_int
int getNodeValue_int(const char *nodepath, int defaultvalue=0) const
get node value as int get the node content and convert it to an integer
Definition: xmlfile.h:522

XMLfile::XMLfile
XMLfile(const std::string &filepath)
constructor for XML-file constructor calls initfile

XMLfile::XMLfile
XMLfile()
XMLfile default constructor.
Definition: xmlfile.cpp:37

XMLfile::getNodeValue_double
double getNodeValue_double(const std::string &nodepath, double defaultvalue=0.) const
get node value as double get the node content and convert it to a double
Definition: xmlfile.h:559

XMLfile::getDir
const std::string getDir() const
get XML file directory if instantiated with a XML-file, return the directory
Definition: xmlfile.h:458

XMLfile::getNodeValue_string
std::string getNodeValue_string(const char *nodepath, std::string defaultvalue=std::string()) const
get node value as string get the node content
Definition: xmlfile.h:507

XMLfile::numqueries
size_t numqueries() const
number of registered queries return the number of active queries
Definition: xmlfile.h:612

XMLfile::initstring
void initstring(const char *xmlstring)
initialize with XML-string instantiating with XML-string
Definition: xmlfile.cpp:72

XMLfile::getcurrentnodepath
std::string getcurrentnodepath() const
get current node path
Definition: xmlfile.h:477

xml_schema::string
::xsd::cxx::tree::string< char, simple_type > string
C++ type corresponding to the string XML Schema built-in type.
Definition: vtk-punstructured.h:270

pos
Definition: FakedOptFFT.h:23

operator<<
std::ostream & operator<<(std::ostream &ostrm, const XMLfile::Node &xmlnode)
write a node to a stream write XML node data to an output stream
Definition: xmlfile.h:659