gsXml.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsForwardDeclarations.h>
#include <gsCore/gsExport.h>

// Default memory sizes
// #define RAPIDXML_STATIC_POOL_SIZE  ( 64*1024 )
// #define RAPIDXML_DYNAMIC_POOL_SIZE ( 64*1024 )

#include <rapidxml/rapidxml.hpp>             // External file
#include <rapidxml/rapidxml_print.hpp>       // External file
//#include <rapidxml/rapidxml_utils.hpp>     // External file
//#include <rapidxml/rapidxml_iterators.hpp> // External file

#include <cstring>

/*
// Forward declare rapidxml structures
namespace rapidxml
{
    template<class Ch> class xml_node;
    template<class Ch> class xml_attribute;
    template<class Ch> class xml_document;
}
*/

#define GSXML_COMMON_FUNCTIONS(obj)             \
    static bool has(gsXmlNode * node)           \
    { return firstByTag(tag(), node) != 0;}     \
    static bool hasAny(gsXmlNode * node)        \
    { return anyByTag(tag(), node) != 0;}       \
    static bool count(gsXmlNode * node)         \
    { return countByTag(tag(), node) != 0; }    \
    static obj * getFirst (gsXmlNode * node)    \
    { return get(firstByTag(tag(), node)); }    \
    static obj * getAny (gsXmlNode * node)      \
    { return get(anyByTag(tag(), node)); }      \
    static  obj * getId (gsXmlNode * node, int id) \
    { return getById< obj >(node, id); }                            \
    static  obj * getLabel(gsXmlNode * node, const std::string & label) \
    { return getByLabel< obj >(node, label); }

#define GSXML_GET_POINTER(obj)          \
    static obj * get (gsXmlNode * node) \
    {   obj * result = new obj;         \
        get_into(node, *result);        \
        return result; }

#define GSXML_GET_INTO(obj)          \
    static void get_into (gsXmlNode * node, obj & result) \
    {   result = *get(node); }

#define TMPLA2(t1,t2)             t1,t2
#define TMPLA3(t1,t2,t3)          t1,t2,t3
#define TMPLA4(t1,t2,t3,t4)       t1,t2,t3,t4

#ifdef gsGmp_ENABLED
// Specialize file I/O to floating point format
#include<sstream>
inline std::istringstream &
operator>>(std::istringstream & is, mpq_class & var)
{
    // read as decimal
    std::string dn;
    if ( !(is >> dn) ) return is;
    const std::string::size_type comma( dn.find(".") );
    if( comma != std::string::npos )
    {
        const std::string::size_type exp = dn.size() - comma - 1;
        const mpz_class num( dn.erase(comma,1), 10);
        mpz_class den;
        mpz_ui_pow_ui(den.get_mpz_t(),10,exp);
        var = mpq_class(num, den);
    }
    else // integer or rational
        var.set_str(dn,10);

    //read as machine float
    //double tmp;
    //is >> tmp;
    //var = tmp;

    var.canonicalize();// remove common factors
    return is;
}

#include <fstream>// for paraview
template <class U> inline std::ofstream & operator<<
(std::ofstream &fs, __gmp_expr<U,U> & var)
{
    fs<<var.get_d();
    // write as rational
    //os << var.get_str(10);
    return fs;
}

#endif

namespace gismo {

template<class T>
inline bool gsGetReal(std::istream & is, T & var)
{
    GISMO_STATIC_ASSERT(!std::numeric_limits<T>::is_integer,
        "The second parameter needs to be an integer type.");
    std::string dn;
    if ( !(is >> dn) ) return false;
    const std::string::size_type slh( dn.find("/") );
    if( slh != std::string::npos )
    {
        var = strtod(dn.substr(0,slh).c_str(), NULL) /
              strtod(dn.substr(slh+1).c_str(), NULL) ;
    }
    else // integer or decimal
        var = strtod(dn.c_str(), NULL);

    return true;
}

template<class Z>
inline bool gsGetInt(std::istream & is, Z & var)
{
  GISMO_STATIC_ASSERT(std::numeric_limits<Z>::is_integer,
        "The second parameter needs to be an integer type.");
  //return static_cast<bool>(is >> var); //C++11
  return !(is >> var).fail();
}

#ifdef gsGmp_ENABLED
template<>
inline bool gsGetReal(std::istream & is, mpq_class & var)
{
    // read as decimal
    bool ok = true;
    std::string dn;
    if ( !(is >> dn) ) return false;
    const std::string::size_type comma( dn.find(".") );
    if( comma != std::string::npos )
    {
        const std::string::size_type exp = dn.size() - comma - 1;
        const mpz_class num( dn.erase(comma,1), 10);// will throw on error
        mpz_class den;
        mpz_ui_pow_ui(den.get_mpz_t(),10,exp);
        var = mpq_class(num, den);
    }
    else // integer or rational
    {
        if ('+'==dn[0]) dn.erase(0, 1);
        ok = (0==var.set_str(dn,10));
    }

    // read as machine float
    //double tmp;
    //is >> tmp;
    //var = tmp;

    var.canonicalize();// remove common factors
    return ok;
}
#endif

//Note: automatic deduction of number traits, however using gsGetReal,
//gsGetInt can reveal type mistakes, so they are preferable
template <typename Z>
typename util::enable_if<std::numeric_limits<Z>::is_integer, bool>::type
gsGetValue(std::istream & is, Z & var)
{ return gsGetInt<Z>(is,var); }

template <typename T>
typename util::enable_if<!std::numeric_limits<T>::is_integer, bool>::type
gsGetValue(std::istream & is, T & var)
{ return gsGetReal<T>(is,var); }

namespace internal {

typedef rapidxml::xml_node<char>        gsXmlNode;
typedef rapidxml::xml_attribute<char>   gsXmlAttribute;
typedef rapidxml::xml_document<char>    gsXmlTree;


template<class Object>
class gsXml
{
private:
    gsXml() { }// Disallow instantization
public:

    static std::string tag ();
/*    {   // Next line will produce compile-time error
        // when class is not specialized for Object
        Object::Object_does_not_exist_ERROR;
        return "";
    }
*/
    static std::string type ();
    static Object * get      (gsXmlNode * node);
    static void     get_into (gsXmlNode * node, Object & result);
    static gsXmlNode * put   (const Object & obj, gsXmlTree & data);

    // Common operations
    static bool     has      (gsXmlNode * node);
    static bool     count    (gsXmlNode * node);
    static Object * getFirst (gsXmlNode * node);
    //static void     getFirst_into (gsXmlNode * node);
    static Object * getAny   (gsXmlNode * node);
    //static void     getAny_into   (gsXmlNode * node);
    static Object * getId    (gsXmlNode * node, int id);
    //static void     getId_into   (gsXmlNode * node, int id, Object & result);
    static Object * getLabel(gsXmlNode * node, const std::string & label);
};

inline gsXmlNode * searchNode(gsXmlNode * root,
                              const std::string & attr_name,
                              const std::string & value,
                              const char *tag_name = NULL )
{
    for (gsXmlNode * child = root->first_node(tag_name);
         child; child = child->next_sibling(tag_name))
    {
        const gsXmlAttribute * attribute = child->first_attribute(attr_name.c_str());
        if ( attribute &&  !strcmp(attribute->value(),value.c_str()) )
            return child;
        else if ( attribute && "time"==attr_name && atof(value.c_str()) == atof(attribute->value()) )
            return child;
    }
    gsWarn <<"gsXmlUtils: No "<< tag_name <<" object with attribute '"<<attr_name<<" = "<< value<<"' found.\n";
    return NULL;
}

inline gsXmlNode* searchId(const int id, gsXmlNode* root,
                           const char* tag_name = NULL,
                           const bool print_warning = true) {
  for (gsXmlNode* child = root->first_node(tag_name); child;
       child = child->next_sibling(tag_name)) {
    const gsXmlAttribute* id_at = child->first_attribute("id");
    if (id_at && atoi(id_at->value()) == id) return child;
  }
  if (print_warning) {
    gsWarn << "gsXmlUtils: No object with id = " << id << " found.\n";
  }
  return NULL;
}

template<class Object>
Object * getByLabel(gsXmlNode * node, const std::string & label)
{
    std::string tag = internal::gsXml<Object>::tag();
    gsXmlNode * nd  = searchNode(node, "label", label, tag.c_str());
    if (nd)
    {
        return internal::gsXml<Object>::get(nd);
    }
    std::cerr<<"gsXmlUtils Warning: "<< internal::gsXml<Object>::tag()
             <<" with label="<<label<<" not found.\n";
    return NULL;
}



template<class Object>
Object * getById(gsXmlNode * node, const int & id)
{
    std::string tag = internal::gsXml<Object>::tag();
    gsXmlNode * nd  = searchId(id, node, tag.c_str());
    if (nd)
    {
        return internal::gsXml<Object>::get(nd);
    }
    std::cerr<<"gsXmlUtils Warning: "<< internal::gsXml<Object>::tag()
             <<" with id="<<id<<" not found.\n";
    return NULL;
}
GISMO_EXPORT char * makeValue( const std::string & value, gsXmlTree & data);

template<class T>
char * makeValue(const gsMatrix<T> & value, gsXmlTree & data,
                 bool transposed);

GISMO_EXPORT gsXmlAttribute *  makeAttribute( const std::string & name,
                                              const std::string & value, gsXmlTree & data);

GISMO_EXPORT gsXmlAttribute *  makeAttribute( const std::string & name,
                                                   const unsigned & value, gsXmlTree & data);

GISMO_EXPORT gsXmlNode *  makeNode( const std::string & name, gsXmlTree & data);

GISMO_EXPORT gsXmlNode * makeNode( const std::string & name,
                                     const std::string & value, gsXmlTree & data);

GISMO_EXPORT gsXmlNode *  makeComment(const std::string &, gsXmlTree & data);

GISMO_EXPORT std::string to_string(const unsigned & i);

GISMO_EXPORT int countByTag(const std::string & tag, gsXmlNode * root );

GISMO_EXPORT int  countByTagType(const std::string & tag,
                                 const std::string & type,
                                 gsXmlNode * root );

GISMO_EXPORT gsXmlNode * firstByTag(const std::string & tag,
                                    gsXmlNode * root );

GISMO_EXPORT gsXmlNode * firstByTagType(const std::string & tag,
                                         const std::string & type,
                                         gsXmlNode * root );

// Helper which finds a node matching \a tag and \a type in the XML
// tree
//GISMO_EXPORT gsXmlNode * anyByTagType(const std::string & tag,
//                                       const std::string & type,
//                                       gsXmlNode * root );

GISMO_EXPORT gsXmlNode * anyByTag(const std::string & tag,
                                  gsXmlNode * root );

GISMO_EXPORT void getBoundaries(gsXmlNode                * node,
                                std::map<int, int>       & ids,
                                std::vector< patchSide > & result);

GISMO_EXPORT void getInterfaces(gsXmlNode* node,
                                const int d,
                                std::map<int, int>& ids,
                                std::vector< boundaryInterface > & result);

GISMO_EXPORT void appendBoxTopology(const gsBoxTopology& topology,
                                    gsXmlNode* node,
                                    gsXmlTree& data);

template<class T>
gsXmlNode * makeNode( const std::string & name,
                      const gsMatrix<T> & value, gsXmlTree & data,
                      bool transposed = false );

template <class T>
void getMatrixFromXml(gsXmlNode* node, unsigned const& rows,
                      unsigned const& cols, gsMatrix<T>& result,
                      const std::string& base_type_flag = "ascii");

template<class T>
gsXmlNode * putMatrixToXml ( gsMatrix<T> const & mat,
                             gsXmlTree & data, std::string name = "Matrix");

template<class T>
void getSparseEntriesFromXml ( gsXmlNode * node,
                               gsSparseEntries<T> & result );

template<class T>
gsXmlNode * putSparseMatrixToXml ( gsSparseMatrix<T> const & mat,
                                   gsXmlTree & data, std::string name = "SparseMatrix");

}// end namespace internal

}// end namespace gismo

#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsXml.hpp)
#endif