Serialization_internal.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 SERIALIZETION_INTERNAL_H
#define SERIALIZETION_INTERNAL_H

#include <cstring>
#include <sstream>
#include <cstddef>
#include <cassert>
#include <stdint.h>
#include <arpa/inet.h>
#include <boost/type_traits/is_fundamental.hpp>

#include "XML.hpp"

namespace FotoSHOCKcore {

namespace Serialization_internal {

    template <typename T>
    class HasSerialize {
        private:
            typedef char yes[1];
            typedef char no[2];

            template <typename U, U> struct type_check;
            template <typename C> static yes& test(type_check<xmlNodePtr(T::*)() const, &C::serialize>*);
            template <typename C> static no& test(...);
        public:
            static const bool value = sizeof(test<T>(0)) == sizeof(yes);
    };

    template<bool T>
    class CompoundTypeSerializer {
        public:
            template<typename C>
            static xmlNodePtr serialize(C /*value*/) {
                // TODO: replace by static assert after move to C++11
                assert("Type doesn't provide the required serialize() function");
                return NULL;
            }

            template<typename C>
            static C deserialize(const xmlNodePtr /*value*/) {
                // TODO: replace by static assert after move to C++11
                assert("Type doesn't provide the required deserialize() function");
                return C();
            }
    };

    template<>
    struct CompoundTypeSerializer<true> {
        public:
            template<typename T>
            static xmlNodePtr serialize(T value) {
                return value.serialize();
            }

            // Assume that if the user provided a serialize function, he also provided
            // a static deserialize function, as these two are closely related.
            template<typename T>
            static T deserialize(const xmlNodePtr value) {
                return T::deserialize(value);
            }
    };


    template <typename T>
    xmlNodePtr serializeGeneral_impl(T value, boost::true_type) {
        std::stringstream os;
        os << value;
        std::string tmp = os.str();
        return xmlNewText(BAD_CAST tmp.c_str());
    }


    template <typename T>
    xmlNodePtr serializeGeneral_impl(T value, boost::false_type) {
        return CompoundTypeSerializer<HasSerialize<T>::value>::serialize(value);
    }


    template <typename T>
    xmlNodePtr serializeGeneral(T value) {
        return serializeGeneral_impl(value, boost::is_fundamental<T>());
    }

    // deserialize functions equivalent to the serializeGeneral and serializeGeneral_impl

    template <typename T>
    T deserializeGeneral_impl(const xmlNodePtr value, boost::true_type) {
        T retVal;
        std::stringstream is(reinterpret_cast<const char*>(value->content));
        is >> retVal;
        return retVal;
    }

    template <typename T>
    T deserializeGeneral_impl(const xmlNodePtr value, boost::false_type) {
        // ISO C++03 14.2/4:
        return CompoundTypeSerializer<HasSerialize<T>::value>::template deserialize<T>(value);
    }

    template <typename T>
    T deserializeGeneral(const xmlNodePtr value) {
        return deserializeGeneral_impl<T>(value, boost::is_fundamental<T>());
    }

    // other usefull functions

    inline uint64_t htonll(uint64_t value) {
        const int test = 1;

        // Check the endianness
        if (*reinterpret_cast<const char*>(&test) == 1) {
            // create a 0xFFFFFFFF mask in a portable way
            uint64_t mask = 0; mask = ~mask;
            const uint32_t high_part = htonl(static_cast<uint32_t>(value >> 32));
            const uint32_t low_part = htonl(static_cast<uint32_t>(value & mask));
            return (static_cast<uint64_t>(low_part) << 32) | high_part;
        }
        else {
            return value;
        }
    }

    inline uint64_t ntohll(uint64_t value) {
        const int test = 1;

        // Check the endianness
        if (*reinterpret_cast<const char*>(&test) == 1) {
            return ( (static_cast<uint64_t>(ntohl(value))) << 32 | ntohl(value>>32) );
        }
        else {
            return value;
        }
    }

}
}

#endif