XmlSerializer.hpp

/*
 *  Copyright 2011, 2012 Lukas Jirkovsky
 *
 *  This file is part of FotoSHOCKcore.
 *
 *  FotoSHOCKcore is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, version 3 of the License.
 *
 *  FotoSHOCKcore 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 Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with FotoSHOCKcore.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef XMLSERIALIZER_H
#define XMLSERIALIZER_H

#include "NVPtype.hpp"
#include "XmlNode.hpp"

namespace FotoSHOCKcore {

class XmlSerializer;


class XmlSerializer {
    public:
        XmlSerializer(const XmlNode& node) : m_node(node)
        {}


        template <typename T>
        XmlSerializer& operator<<(const NVPtype<T>& nvp) {
            XmlNode(m_node, nvp);
            return *this;
        }

        XmlSerializer& operator<<(const XmlNode& node) {
            xmlAddChild(m_node.node(), node.node());
            return *this;
        }


        // TODO: allow deserializing of multiple elements with a same name
        template <typename T>
        T deserialize(const char* name) {
            // find a corresponding xmlNode by traversinf the children of the m_node
            xmlNodePtr currNode = m_node.node()->children;
            for (; currNode; currNode = currNode->next) {
                if (currNode->type == XML::XML_ELEMENT_NODE) {
                    if (! strcmp(name, reinterpret_cast<const char*>(currNode->name))) {
                        // node found
                        break;
                    }
                }
            }

            if (! currNode) {
                // TODO: throw an exception
            }

            // deserialize the value from node
            // we need to deserialize from the children (for primitive types tmp should be XML_TEXT_NODE)
            xmlNodePtr tmp = currNode->children;
            if (tmp) {
                return TypeSerializer<T>::deserialize(tmp);
            }

            // return a default value for the type (possibly throw an exception)
            return T();
        }
    private:
        const XmlNode& m_node;
};

}

#endif // OPERATIONSERIALIZER_H