NVPtype.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 NVPTYPE_H
#define NVPTYPE_H

#include "TypeSerializer.hpp"

namespace FotoSHOCKcore {

class GraphManager;


template <typename T>
class NVPtype {
    public:
        friend class XmlNode;

        NVPtype(const char* name, T value, std::size_t /*length*/ = 1) : m_name(BAD_CAST name) {
            m_content = TypeSerializer<T>::serialize(value);
        }

        ~NVPtype()
        {}
    protected:
        const xmlChar* m_name;
        // text node (ie. node creted using xmlNewText())
        xmlNodePtr m_content;
};


template <typename T>
class NVPtype<T*> {
    public:
        friend class XmlNode;

        NVPtype(const char* name, T* value, std::size_t length) : m_name(BAD_CAST name) {
            if (length > 0) {
                // TODO: use TypeSerializer<T>::serialize(value) to store value of each element of the array
            }
            else {
                m_content = NULL;
            }
        }

        ~NVPtype()
        {}
    protected:
        const xmlChar* m_name;
        xmlNodePtr m_content;
};

/*
 * SPECIALIZATIONS OF NVPtype FOR COMMON TYPES
 */


template <>
class NVPtype<const char*> {
    public:
        friend class XmlNode;

        NVPtype(const char* name, const char* value, std::size_t /*length*/) : m_name(BAD_CAST name) {
            m_content = TypeSerializer<const char*>::serialize(value);
        }

        ~NVPtype()
        {}
    protected:
        const xmlChar* m_name;
        xmlNodePtr m_content;
};


inline NVPtype<int*> nvp(const char* name) {
    return NVPtype<int*>(name, (int*)0, 0);
}


template <typename T>
NVPtype<T> nvp(const char* name, T value) {
    return NVPtype<T>(name, value, 1);
}


template <typename T>
NVPtype<T*> nvp(const char* name, T* value, std::size_t size) {
    return NVPtype<T*>(name, value, size);
}

}

#endif // NVPTYPE_H