drwnXMLUtils.h

Go to the documentation of this file.

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2017, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnXMLUtils.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include "Eigen/Core"

#include "drwnLogger.h"
#include "drwnXMLParser.h"

// drwnBase64 ----------------------------------------------------------------

namespace drwnBase64 {
    extern const char *LUT;
    extern const char FILL;
    extern bool INSERT_NEWLINES;

    char *encode(const unsigned char *data, size_t length);
    unsigned char *decode(const char *data);
};

// drwnXMLUtils --------------------------------------------------------------

typedef enum _drwnXMLEncoderType {
    DRWN_XML_TEXT,   
    DRWN_XML_BASE64  
} drwnXMLEncoderType;

namespace drwnXMLUtils {
    extern drwnXMLEncoderType DEFAULT_ENCODER;
    drwnXMLEncoderType getEncoderType(const char *str);

    drwnXMLNode& serialize(drwnXMLNode& xml, const char *buffer, size_t length);
    drwnXMLNode& serialize(drwnXMLNode& xml, const Eigen::VectorXd& v);
    drwnXMLNode& serialize(drwnXMLNode& xml, const Eigen::MatrixXd& m);

    drwnXMLNode& deserialize(drwnXMLNode& xml, char *buffer, size_t length);
    drwnXMLNode& deserialize(drwnXMLNode& xml, Eigen::VectorXd& v);
    drwnXMLNode& deserialize(drwnXMLNode& xml, Eigen::MatrixXd& m);

    template<typename T>
    struct save_node { void operator()(const T& o, drwnXMLNode& node) { o.save(node); }; };

    template<typename T>
    struct save_node<T *> { void operator()(T* const& o, drwnXMLNode& node) { o->save(node); }; };

    template<class RandomAccessIterator>
    void save(drwnXMLNode& xml, const char *tag,
        RandomAccessIterator first, RandomAccessIterator last) {
        save_node<typename RandomAccessIterator::value_type> functor;
        while (first != last) {
            drwnXMLNode *node = xml.document()->allocate_node(rapidxml::node_element,
                xml.document()->allocate_string(tag));
            xml.append_node(node);
            functor(*first, *node);
            ++first;
        }
    }

    template<class Container>
    void save(drwnXMLNode& xml, const char *tag, const Container& container) {
        save(xml, tag, container.begin(), container.end());
    }

    template<class Container>
    void write(const char *filename, const char *root, const char *tag,
        const Container& container) {
        DRWN_ASSERT(filename != NULL);
        drwnXMLDoc xml;
        drwnXMLNode *node = xml.allocate_node(rapidxml::node_element, xml.allocate_string(root));
        xml.append_node(node);
        drwnXMLUtils::save(*node, tag, container);
        ofstream ofs(filename);
        ofs << xml << endl;
        ofs.close();
    }


    template<typename T>
    struct load_node {
        T operator()(drwnXMLNode& node) { T o; o.load(node); return o; };
    };

    template<typename T>
    struct load_node<T *> {
        T* operator()(drwnXMLNode& node) { T *o = new T(); o->load(node); return o; };
    };

    template<class Container>
    void load(drwnXMLNode& xml, const char *tag, Container& container) {
        typename Container::iterator it(container.end());
        load_node<typename Container::value_type> functor;

        for (drwnXMLNode *node = xml.first_node(tag); node != NULL; node = node->next_sibling(tag)) {
            // assumes default constructable value type
            it = container.insert(it, functor(*node));
            ++it;
        }
    }

    template<class Container>
    void read(const char *filename, const char *root, const char *tag,
        Container& container) {
        DRWN_ASSERT(filename != NULL);
        drwnXMLDoc xml;
        drwnParseXMLFile(xml, filename, root);
        DRWN_ASSERT(!drwnIsXMLEmpty(xml));
        load(xml, tag, container);
    }

    void dump(drwnXMLNode& xml);
};