portable_iarchive.hpp

Go to the documentation of this file.

/*****************************************************************************/
/*****************************************************************************/

#ifdef _QX_ENABLE_BOOST_SERIALIZATION
#if _QX_SERIALIZE_PORTABLE_BINARY
#ifndef _QX_PORTABLE_BINARY_IARCHIVE_H_
#define _QX_PORTABLE_BINARY_IARCHIVE_H_

#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#pragma warning(disable:4661)
#endif // _MSC_VER

#include <istream>

// basic headers
#include <boost/version.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/archive/basic_binary_iprimitive.hpp>
#include <boost/archive/basic_binary_iarchive.hpp>

#if BOOST_VERSION >= 103500 && BOOST_VERSION < 105600
#include <boost/archive/shared_ptr_helper.hpp>
#endif

// endian and fpclassify
#if BOOST_VERSION < 103600
#include <boost/integer/endian.hpp>
#include <boost/math/fpclassify.hpp>
#elif BOOST_VERSION < 104800
#include <boost/spirit/home/support/detail/integer/endian.hpp>
#include <boost/spirit/home/support/detail/math/fpclassify.hpp>
#else
#include <boost/spirit/home/support/detail/endian/endian.hpp>
#include <boost/spirit/home/support/detail/math/fpclassify.hpp>
#endif

// namespace alias
#if BOOST_VERSION < 103800
namespace fp = boost::math;
#else
namespace fp = boost::spirit::math;
#endif

// namespace alias endian
#if BOOST_VERSION < 104800
namespace endian = boost::detail;
#else
namespace endian = boost::spirit::detail;
#endif

#if BOOST_VERSION >= 104500 && !defined BOOST_NO_STD_WSTRING
// used for wstring to utf8 conversion
#include <boost/program_options/config.hpp>
#include <boost/program_options/detail/convert.hpp>
#endif

// generic type traits for numeric types
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_unsigned.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/is_floating_point.hpp>

#include "portable_archive_exception.hpp"

// hint from Johan Rade: on VMS there is still support for
// the VAX floating point format and this macro detects it
#if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
#error "VAX floating point format is not supported!"
#endif

namespace eos {

        // forward declaration
        class portable_iarchive;

        typedef boost::archive::basic_binary_iprimitive<
                portable_iarchive
        #if BOOST_VERSION < 103400
                , std::istream
        #else
                , std::istream::char_type 
                , std::istream::traits_type
        #endif
        > portable_iprimitive;

        class portable_iarchive : public portable_iprimitive

                // the example derives from common_oarchive but that lacks the
                // load_override functions so we chose to stay one level higher
                , public boost::archive::basic_binary_iarchive<portable_iarchive>

        #if BOOST_VERSION >= 103500 && BOOST_VERSION < 105600
                // mix-in helper class for serializing shared_ptr
                , public boost::archive::detail::shared_ptr_helper
        #endif
        {
                // only needed for Robert's hack in basic_binary_iarchive::init
                friend class boost::archive::basic_binary_iarchive<portable_iarchive>;

                // workaround for gcc: use a dummy struct
                // as additional argument type for overloading
                template <int> struct dummy { dummy(int) {}};

                // loads directly from stream
                inline signed char load_signed_char()
                { 
                        signed char c; 
                        portable_iprimitive::load(c); 
                        return c; 
                }

                // archive initialization
                void init(unsigned flags)
                {
                        using namespace boost::archive;
                        archive_version_type input_library_version(3);

                        // it is vital to have version information!
                        // if we don't have any we assume boost 1.33
                        if (flags & no_header)
                                set_library_version(input_library_version);

                        // extract and check the magic eos byte
                        else if (load_signed_char() != magic_byte)
                                throw archive_exception(archive_exception::invalid_signature);

                        else
                        {
                                // extract version information
                                operator>>(input_library_version);

                                // throw if file version is newer than we are
                                if (input_library_version > archive_version)
                                        throw archive_exception(archive_exception::unsupported_version);

                                // else set the library version accordingly
                                else set_library_version(input_library_version);
                        }
                }

        public:
                portable_iarchive(std::istream& is, unsigned flags = 0)
                #if BOOST_VERSION < 103400
                        : portable_iprimitive(is, flags & boost::archive::no_codecvt)
                #else
                        : portable_iprimitive(*is.rdbuf(), flags & boost::archive::no_codecvt)
                #endif
                        , boost::archive::basic_binary_iarchive<portable_iarchive>(flags)
                {
                        init(flags);
                }

        #if BOOST_VERSION >= 103400
                portable_iarchive(std::streambuf& sb, unsigned flags = 0)
                        : portable_iprimitive(sb, flags & boost::archive::no_codecvt)
                        , boost::archive::basic_binary_iarchive<portable_iarchive>(flags)
                {
                        init(flags);
                }
        #endif

                void load(std::string& s) 
                {
                        portable_iprimitive::load(s);
                }

        #ifndef BOOST_NO_STD_WSTRING

                void load(std::wstring& s)
                {
                        std::string utf8;
                        load(utf8);
                        s = boost::from_utf8(utf8);
                }
        #endif

                void load(bool& b) 
                { 
                        switch (signed char c = load_signed_char())
                        {
                        case 0: b = false; break;
                        case 1: b = load_signed_char(); break;
                        default: throw portable_archive_exception(c);
                        }
                }

                template <typename T>
                typename boost::enable_if<boost::is_integral<T> >::type
                load(T & t, dummy<2> = 0)
                {
                        // get the number of bytes in the stream
                        if (signed char size = load_signed_char())
                        {
                                // check for negative value in unsigned type
                                if (size < 0 && boost::is_unsigned<T>::value)
                                        throw portable_archive_exception();

                                // check that our type T is large enough
                                else if ((unsigned) abs(size) > sizeof(T)) 
                                        throw portable_archive_exception(size);

                                // reconstruct the value
                                T temp = size < 0 ? -1 : 0;
                                load_binary(&temp, abs(size));

                                // load the value from little endian - it is then converted
                                // to the target type T and fits it because size <= sizeof(T)
                                t = endian::load_little_endian<T, sizeof(T)>(&temp);
                        }

                        else t = 0; // zero optimization
                }

                template <typename T>
                typename boost::enable_if<boost::is_floating_point<T> >::type
                load(T & t, dummy<3> = 0)
                {
                        typedef typename fp::detail::fp_traits<T>::type traits;

                        // if you end here there are three possibilities:
                        // 1. you're serializing a long double which is not portable
                        // 2. you're serializing a double but have no 64 bit integer
                        // 3. your machine is using an unknown floating point format
                        // after reading the note above you still might decide to 
                        // deactivate this static assert and try if it works out.
                        typename traits::bits bits;
                        BOOST_STATIC_ASSERT(sizeof(bits) == sizeof(T));
                        BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_iec559);

                        load(bits);
                        traits::set_bits(t, bits);

                        // if the no_infnan flag is set we must throw here
                        if (get_flags() & no_infnan && !fp::isfinite(t))
                                throw portable_archive_exception(t);

                        // if you end here your floating point type does not support 
                        // denormalized numbers. this might be the case even though 
                        // your type conforms to IEC 559 (and thus to IEEE 754)
                        if (std::numeric_limits<T>::has_denorm == std::denorm_absent
                                && fp::fpclassify(t) == (int) FP_SUBNORMAL) // GCC4
                                throw portable_archive_exception(t);
                }

                // in boost 1.44 version_type was splitted into library_version_type and
                // item_version_type, plus a whole bunch of additional strong typedefs.
                template <typename T>
                typename boost::disable_if<boost::is_arithmetic<T> >::type
                load(T& t, dummy<4> = 0)
                {
                        // we provide a generic load routine for all types that feature
                        // conversion operators into an unsigned integer value like those
                        // created through BOOST_STRONG_TYPEDEF(X, some unsigned int) like
                        // library_version_type, collection_size_type, item_version_type,
                        // class_id_type, object_id_type, version_type and tracking_type
                        load((typename boost::uint_t<sizeof(T)*CHAR_BIT>::least&)(t));
                }
        };

} // namespace eos

// this is required by export which registers all of your
// classes with all the inbuilt archives plus our archive.
#if BOOST_VERSION < 103500
#define BOOST_ARCHIVE_CUSTOM_IARCHIVE_TYPES eos::portable_iarchive
#else
BOOST_SERIALIZATION_REGISTER_ARCHIVE(eos::portable_iarchive)
#endif

// if you include this header multiple times and your compiler is picky
// about multiple template instantiations (eg. gcc is) then you need to
// define NO_EXPLICIT_TEMPLATE_INSTANTIATION before every include but one
// or you move the instantiation section into an implementation file
#ifndef NO_EXPLICIT_TEMPLATE_INSTANTIATION

#ifndef _QX_BOOST_ARCHIVE_SERIALIZER_IMPL_DEFINED_
#define _QX_BOOST_ARCHIVE_SERIALIZER_IMPL_DEFINED_

#include <boost/archive/impl/basic_binary_iarchive.ipp>
#include <boost/archive/impl/basic_binary_oarchive.ipp>
#include <boost/archive/impl/basic_binary_iprimitive.ipp>
#include <boost/archive/impl/basic_binary_oprimitive.ipp>

#if _QX_SERIALIZE_TEXT
#include <boost/archive/impl/basic_text_oprimitive.ipp>
#include <boost/archive/impl/basic_text_iprimitive.ipp>
#include <boost/archive/impl/basic_text_oarchive.ipp>
#include <boost/archive/impl/basic_text_iarchive.ipp>
#endif // _QX_SERIALIZE_TEXT

#if (BOOST_VERSION < 104000)
#include <boost/archive/impl/archive_pointer_iserializer.ipp>
#include <boost/archive/impl/archive_pointer_oserializer.ipp>
#elif !defined BOOST_ARCHIVE_SERIALIZER_INCLUDED
#include <boost/archive/impl/archive_serializer_map.ipp>
#define BOOST_ARCHIVE_SERIALIZER_INCLUDED
#endif // (BOOST_VERSION < 104000)

#endif // _QX_BOOST_ARCHIVE_SERIALIZER_IMPL_DEFINED_

namespace boost { namespace archive {

        // explicitly instantiate for this type of binary stream
        template class basic_binary_iarchive<eos::portable_iarchive>;

        template class basic_binary_iprimitive<
                eos::portable_iarchive
        #if BOOST_VERSION < 103400
                , std::istream
        #else
                , std::istream::char_type
                , std::istream::traits_type
        #endif
        >;

#if (! _QX_USE_EXPORT_DLL_BOOST_SERIALIZATION_SINGLETON)
#if (BOOST_VERSION < 104000)
        template class detail::archive_pointer_iserializer<eos::portable_iarchive>;
#else // (BOOST_VERSION < 104000)
        template class detail::archive_serializer_map<eos::portable_iarchive>;
#endif // (BOOST_VERSION < 104000)
#endif // (! _QX_USE_EXPORT_DLL_BOOST_SERIALIZATION_SINGLETON)

} } // namespace boost::archive

#endif // NO_EXPLICIT_TEMPLATE_INSTANTIATION

#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER

#endif // _QX_PORTABLE_BINARY_IARCHIVE_H_
#endif // _QX_SERIALIZE_PORTABLE_BINARY
#endif // _QX_ENABLE_BOOST_SERIALIZATION