xmlfilereader.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of libgvectors.
// libgvectors is a C++ library intended for visualizing mathematical vectors.
// Copyright (C) 2007  Rafael Ostertag
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
// USA.
//
// $Id: xmlfilereader_8h-source.html,v 1.1 2007-09-08 19:02:38 rafi Exp $
// 
// File:   xmlfilereader.h
// Author: Rafael Ostertag
//
// Created on August 20, 2007, 8:46 PM
//

#ifndef _XMLFILEREADER_H
#define _XMLFILEREADER_H

#include <gvectors-config.h>

#ifdef HAVE_LIBXML
#include <stdlib.h>

#include <string>

#include <libxml++/libxml++.h>
#include <gvectortypes.h>
#include <gvexceptions.h>
#include <vectorstore.h>
#include <filereader.h>
#include <visualvector.h>
#include <color.h>

namespace GVectors {
    // libxml2 uses Glib::ustring
#if HAVE_LIBXML == 2

    const Glib::ustring VERSION_0_1 = "0.1";
    const Glib::ustring NODE_NAME_VECTOR = "vector";
    const Glib::ustring NODE_NAME_COORDINATES = "coordinates";
    const Glib::ustring NODE_NAME_COMPONENTS[4] = {
        "xcomp",
        "ycomp",
        "zcomp",
        ""
    };
    const Glib::ustring NODE_NAME_XCOMP = "xcomp";
    const Glib::ustring NODE_NAME_YCOMP = "ycomp";
    const Glib::ustring NODE_NAME_ZCOMP = "zcomp";
    const Glib::ustring NODE_NAME_COLOR = "color";
    const Glib::ustring NODE_NAME_COLORS[4] = {
        "red",
        "green",
        "blue",
        ""
    };
    const Glib::ustring NODE_NAME_RED = "red";
    const Glib::ustring NODE_NAME_GREEN = "green";
    const Glib::ustring NODE_NAME_BLUE = "blue";
#else /* HAVE_LIBXML == 2 */

    const std::string VERSION_0_1 = "0.1";
    const std::string NODE_NAME_VECTOR = "vector";
    const std::string NODE_NAME_COORDINATES = "coordinates";
    const std::string NODE_NAME_COMPONENTS[4] = {
        "xcomp",
        "ycomp",
        "zcomp",
        ""
    };
    const std::string NODE_NAME_XCOMP = "xcomp";
    const std::string NODE_NAME_YCOMP = "ycomp";
    const std::string NODE_NAME_ZCOMP = "zcomp";
    const std::string NODE_NAME_COLOR = "color";
    const std::string NODE_NAME_COLORS[4] = {
        "red",
        "green",
        "blue",
        ""
    };
    const std::string NODE_NAME_RED = "red";
    const std::string NODE_NAME_GREEN = "green";
    const std::string NODE_NAME_BLUE = "blue";
#endif

    template<class Fct> class XMLReader : public FileReader<Fct> {
    private:
        std::string filename;
        xmlpp::DomParser parser;
        
        GVector get_vector(const xmlpp::Node* coordnode) {
            if (coordnode==0)
                throw GVEXMLInvalid();
#if HAVE_LIBXML == 2            
            Glib::ustring nodename = coordnode->get_name();
#else
            std::string nodename = coordnode->get_name();
#endif
            if (nodename!=NODE_NAME_COORDINATES)
                throw GVEXMLInvalid();
            
            // Get the components
            double dcomps[3];
            double* d_ptr = dcomps;
            
#if HAVE_LIBXML == 2
            const Glib::ustring* us_ptr = NODE_NAME_COMPONENTS;
            while(*us_ptr != Glib::ustring("") ) {
#else
                const std::string* us_ptr = NODE_NAME_COMPONENTS;
                while(*us_ptr != std::string("") ) {
#endif
                    const xmlpp::Node* comp = *(coordnode->get_children(*us_ptr).begin());
                    if (comp==0)
                        throw GVEXMLInvalid();
                    const xmlpp::ContentNode* ncontent = dynamic_cast<const xmlpp::ContentNode*>(*(comp->get_children().begin()));
                    if (ncontent==0)
                        throw GVEXMLInvalid();
                    double dval = strtod(ncontent->get_content().c_str(), NULL);
                    *d_ptr = dval;
                    d_ptr++;
                    us_ptr++;
                }
                return GVector(dcomps[0],dcomps[1],dcomps[2]);
            }

            Color get_color(const xmlpp::Node* colnode) {
                if (colnode==0)
                    throw GVEXMLInvalid();
                
#if HAVE_LIBXML == 2
                Glib::ustring nodename = colnode->get_name();
#else
                std::string nodename = colnode->get_name();
#endif
                if (nodename!=NODE_NAME_COLOR)
                    throw GVEXMLInvalid();
                
                // Get the components
                double dcols[3];
                double* d_ptr = dcols;
#if HAVE_LIBXML == 2
                const Glib::ustring* us_ptr = NODE_NAME_COLORS;
                while(*us_ptr != Glib::ustring("") ) {
#else
                    const std::string* us_ptr = NODE_NAME_COLORS;
                    while(*us_ptr != std::string("") ) {
#endif
                        const xmlpp::Node* col = *(colnode->get_children(*us_ptr).begin());
                        if (col==0)
                            throw GVEXMLInvalid();
                        const xmlpp::ContentNode* ncontent = dynamic_cast<const xmlpp::ContentNode*>(*(col->get_children().begin()) );
                        if (ncontent==0)
                            throw GVEXMLInvalid();
                        double dval = strtod(ncontent->get_content().c_str(), NULL);
                        *d_ptr = dval;
                        d_ptr++;
                        us_ptr++;
                    }
                    return Color(dcols[0],dcols[1],dcols[2]);
                }
                
                VisualVector get_visualvector(const xmlpp::Node* vvecnode) {
                    if (vvecnode==0)
                        throw GVEXMLInvalid();
                    
#if HAVE_LIBXML == 2
                    Glib::ustring nodename = vvecnode->get_name();
#else
                    std::string nodename = vvecnode->get_name();
#endif
                    if (nodename!=NODE_NAME_VECTOR)
                        throw GVEXMLInvalid();
                    
                    const xmlpp::Element* nodeelement = dynamic_cast<const xmlpp::Element*>(vvecnode);
                    if (nodeelement==0)
                        throw GVEXMLInvalid();
                    
                    // Get the tag of the vector
                    const xmlpp::Attribute* attribute = nodeelement->get_attribute("tag");
                    if (attribute==0)
                        throw GVEXMLInvalid();
                    
                    // Get the components
                    const xmlpp::Node* cnode = *(vvecnode->get_children(NODE_NAME_COORDINATES).begin());
                    GVector vec(get_vector(cnode));
                    
                    // Get the color
                    cnode = *(vvecnode->get_children(NODE_NAME_COLOR).begin());
                    Color col(get_color(cnode));
                    VisualVector return_value(vec);
                    return_value.set_tag(attribute->get_value().c_str());
                    return_value.set_color(col);
                    
                    return return_value;
                }
                
                void read_vectors(vslevel_t level, xmlpp::Node* node) {
                    VisualVector vv(get_visualvector(node));
                    FileReader<Fct>::put(level, vv);
                    
                    xmlpp::Node::NodeList children = node->get_children(NODE_NAME_VECTOR);
                    xmlpp::Node::NodeList::const_iterator it = children.begin();
                    while (it!=children.end() ) {
                        read_vectors(level+1, *it);
                        it++;
                    }
                }
                
            public:
                XMLReader(std::string fn, VectorStore& vs, Fct callback) : FileReader<Fct>(vs, callback), filename(fn), parser(fn, true) {
                    if (!parser)
                        throw GVEXMLInvalid();
                }
                
                XMLReader(const XMLReader& xr) : FileReader<Fct>(xr), filename(xr.filename), parser(filename, true) {
                    // Empty
                }
                
                virtual ~XMLReader() {
                    // Empty
                }

                void read() {
                    const xmlpp::Node* parent_node = parser.get_document()->get_root_node();
                    const xmlpp::Element* pn_element = dynamic_cast<const xmlpp::Element*>(parent_node);
                    if (pn_element==0)
                        throw GVEXMLInvalid();
                    
                    const xmlpp::Attribute* version = pn_element->get_attribute("version");
                    if (version->get_value()!=VERSION_0_1)
                        throw GVEXMLInvalid();
                    
                    const xmlpp::Node::NodeList vectors = parent_node->get_children(NODE_NAME_VECTOR);
                    xmlpp::Node::NodeList::const_iterator it = vectors.begin();
                    while (it!=vectors.end() ) {
                        read_vectors(TOP_LEVEL_NUM, *it);
                        it++;
                    }
                }
            };
        }
        
#endif /* HAVE_LIBXML */
        
#endif  /* _XMLFILEREADER_H */

---