TypeSerializer.hpp

/*
 *  Copyright 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 TYPESERIALIZER_H
#define TYPESERIALIZER_H

#include <cstdlib>
#include <cstdio>

#include "Serialization_internal.hpp"

namespace FotoSHOCKcore {

template <typename T>
class TypeSerializer {
    public:
        static xmlNodePtr serialize(T value) {
            return Serialization_internal::serializeGeneral(value);
        }

        static const T deserialize(const xmlNodePtr value) {
            return Serialization_internal::deserializeGeneral<T>(value);
        }
};

template <>
class TypeSerializer<const char*> {
    public:
        static xmlNodePtr serialize(const char* value) {
            return xmlNewText(BAD_CAST value);
        }

        static const char* deserialize(const xmlNodePtr value) {
            std::size_t len = strlen(reinterpret_cast<const char*>(value->content));
            char* tmp = new char[len + 1];
            std::memcpy(tmp, value->content, len);
            tmp[len] = '\0';
            return tmp;
        }
};

template <>
class TypeSerializer<float> {
    public:
        static xmlNodePtr serialize(float value) {
            char* tmp = new char[9];
            uint32_t i = *reinterpret_cast<uint32_t*>(&value);
            std::sprintf(tmp, "%X", htonl(i));
            tmp[8] = '\0';

            xmlNodePtr node = xmlNewText(BAD_CAST tmp);
            delete[] tmp;
            return node;
        }

        static const float deserialize(const xmlNodePtr value) {
            uint32_t i = static_cast<uint32_t>(std::strtol(reinterpret_cast<const char*>(value->content), 0, 16));
            i = ntohl(i);
            float retVal = *reinterpret_cast<float*>(&i);
            return retVal;
        }
};

template <>
class TypeSerializer<double> {
    public:
        static xmlNodePtr serialize(double value) {
            char* tmp = new char[17];
            uint64_t i = *reinterpret_cast<uint64_t*>(&value);
            std::sprintf(tmp, "%lX", Serialization_internal::htonll(i));
            tmp[16] = '\0';

            xmlNodePtr node = xmlNewText(BAD_CAST tmp);
            delete[] tmp;
            return node;
        }

        static const double deserialize(const xmlNodePtr value) {
            uint64_t i = std::strtol(reinterpret_cast<const char*>(value->content), 0, 16);
            i = Serialization_internal::ntohll(i);
            double retVal = *reinterpret_cast<double*>(&i);
            return retVal;
        }
};

}

#endif