XML.h

Go to the documentation of this file.

 
#ifndef ETISS_FAULT_XML_H_
#define ETISS_FAULT_XML_H_
 
#include <list>
#include <string>
 
#ifndef NO_ETISS
#include "etiss/fault/Defs.h"
#include "etiss/fault/xml/pugixml.hpp"
#else
#include "fault/Defs.h"
#include "fault/xml/pugixml.hpp"
#endif
 
#include <cstdio>
 
namespace etiss
{
 
namespace fault
{
 
// some helper for changing Core Names
extern int coreIDActuallXML;
void setCoreName(std::string &str);
 
#if ETISS_FAULT_XML
 
namespace xml
{
 
class Diagnostics
{
  public:
    std::list<std::string> warnings;
    std::list<std::string> errors;
    void ignoredNode(const pugi::xml_node &node, const std::string &msg);
    void unexpectedNode(const pugi::xml_node &node, const std::string &msg);
    void print(std::ostream &out) const;
};
 
#if CXX0X_UP_SUPPORTED
template <typename T>
bool parse(pugi::xml_node node, T &dst, Diagnostics &diag)
{
    static_assert((sizeof(T) == -1), "etiss::fault::xml::parse needs to be specialized.");
    return false;
}
template <typename T>
bool write(pugi::xml_node node, const T &src, Diagnostics &diag)
{
    static_assert((sizeof(T) == -1), "etiss::fault::xml::write needs to be specialized.");
    return false;
}
#else
template <typename T>
bool parse(pugi::xml_node node, T &dst, Diagnostics &diag);
template <typename T>
bool write(pugi::xml_node node, const T &src, Diagnostics &diag);
#endif
 
#if CXX0X_UP_SUPPORTED
template <typename T>
bool parse_attr(pugi::xml_node node, const std::string &attr_name, T &dst, Diagnostics &diag)
{
    static_assert((sizeof(T) == -1), "etiss::fault::xml::parse_attr needs to be specialized.");
    return false;
}
template <typename T>
bool write_attr(pugi::xml_node node, const std::string &attr_name, const T &src, Diagnostics &diag)
{
    static_assert((sizeof(T) == -1), "etiss::fault::xml::write_attr needs to be specialized.");
    return false;
}
#else
template <typename T>
bool parse_attr(pugi::xml_node node, const std::string &attr_name, T &dst, Diagnostics &diag);
template <typename T>
bool write_attr(pugi::xml_node node, const std::string &attr_name, const T &src, Diagnostics &diag);
#endif
 
 
template <>
bool parse<std::string>(pugi::xml_node node, std::string &dst, Diagnostics &diag);
template <>
bool write<std::string>(pugi::xml_node node, const std::string &src, Diagnostics &diag);
 
template <>
bool parse<uint64_t>(pugi::xml_node node, uint64_t &dst, Diagnostics &diag);
 
bool parse_hex(pugi::xml_node node, uint64_t &dst, Diagnostics &diag);
template <>
bool write<uint64_t>(pugi::xml_node node, const uint64_t &src, Diagnostics &diag);
 
template <>
bool parse<unsigned>(pugi::xml_node node, unsigned &dst, Diagnostics &diag);
template <>
bool write<unsigned>(pugi::xml_node node, const unsigned &src, Diagnostics &diag);
 
template <>
bool parse_attr<std::string>(pugi::xml_node node, const std::string &attr_name, std::string &dst, Diagnostics &diag);
template <>
bool write_attr<std::string>(pugi::xml_node node, const std::string &attr_name, const std::string &src,
                             Diagnostics &diag);
 
template <typename T>
bool fromString(const std::string &s, T &val);
 
template <>
bool fromString<uint64_t>(const std::string &s, uint64_t &val);
template <>
bool fromString<unsigned>(const std::string &s, unsigned &val);
 
bool hasName(const pugi::xml_node &node, const std::string &name);
bool hasName(const pugi::xml_attribute &attr, const std::string &name);
 
pugi::xml_node findSingleNode(pugi::xml_node node, const std::string &name, Diagnostics &diag);
 
 
} // namespace xml
#endif
} // namespace fault
 
} // namespace etiss
 
#endif