portable_oarchive.hpp

Go to the documentation of this file.

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

#ifdef _QX_ENABLE_BOOST_SERIALIZATION
#if _QX_SERIALIZE_PORTABLE_BINARY
#ifndef _QX_PORTABLE_BINARY_OARCHIVE_H_
#define _QX_PORTABLE_BINARY_OARCHIVE_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 <ostream>

// basic headers
#include <boost/version.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/archive/basic_binary_oprimitive.hpp>
#include <boost/archive/basic_binary_oarchive.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 fp_classify
#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_signed.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_oarchive;

        typedef boost::archive::basic_binary_oprimitive<
                portable_oarchive
        #if BOOST_VERSION < 103400
                , std::ostream
        #else
                , std::ostream::char_type 
                , std::ostream::traits_type
        #endif
        > portable_oprimitive;

        class portable_oarchive : public portable_oprimitive

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

        #if BOOST_VERSION >= 103500 && BOOST_VERSION < 105600
                // mix-in helper class for serializing shared_ptr
                , public boost::archive::detail::shared_ptr_helper
        #endif
        {
                // workaround for gcc: use a dummy struct
                // as additional argument type for overloading
                template<int> struct dummy { dummy(int) {}};

                // stores a signed char directly to stream
                inline void save_signed_char(const signed char& c) 
                { 
                        portable_oprimitive::save(c); 
                }

                // archive initialization
                void init(unsigned flags)
                {
                        // it is vital to have version information if the archive is
                        // to be parsed with a newer version of boost::serialization
                        // therefor we create a header, no header means boost 1.33
                        if (flags & boost::archive::no_header)
                                BOOST_ASSERT(archive_version == 3);
                        else
                        {
                                // write our minimalistic header (magic byte plus version)
                                // the boost archives write a string instead - by calling
                                // boost::archive::basic_binary_oarchive<derived_t>::init()
                                save_signed_char(magic_byte);

                                // write current version
//                              save<unsigned>(archive_version);
                                operator<<(archive_version);
                        }
                }

        public:
                portable_oarchive(std::ostream& os, unsigned flags = 0)
                #if BOOST_VERSION < 103400
                        : portable_oprimitive(os, flags & boost::archive::no_codecvt)
                #else
                        : portable_oprimitive(*os.rdbuf(), flags & boost::archive::no_codecvt)
                #endif
                        , boost::archive::basic_binary_oarchive<portable_oarchive>(flags)
                {
                        init(flags);
                }

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

                void save(const std::string& s)
                {
                        portable_oprimitive::save(s);
                }

        #ifndef BOOST_NO_STD_WSTRING

                void save(const std::wstring& s)
                {
                        save(boost::to_utf8(s));
                }
        #endif

                void save(const bool& b)
                {
                        save_signed_char(b);
                        if (b) save_signed_char('T');
                }

                template <typename T>
                typename boost::enable_if<boost::is_integral<T> >::type
                save(const T & t, dummy<2> = 0)
                {
                        if (T temp = t)
                        {
                                // examine the number of bytes
                                // needed to represent the number
                                signed char size = 0;
                                do { temp >>= CHAR_BIT; ++size; } 
                                while (temp != 0 && temp != (T) -1);

                                // encode the sign bit into the size
                                save_signed_char(t > 0 ? size : -size);
                                BOOST_ASSERT(t > 0 || boost::is_signed<T>::value);

                                // we choose to use little endian because this way we just
                                // save the first size bytes to the stream and skip the rest
                                endian::store_little_endian<T, sizeof(T)>(&temp, t);

                                save_binary(&temp, size);
                        }
                        // zero optimization
                        else save_signed_char(0);
                }

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

                        // 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 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);

                        // examine value closely
                        switch (fp::fpclassify(t))
                        {
                        //case FP_ZERO: bits = 0; break; 
                        case FP_NAN: bits = traits::exponent | traits::mantissa; break;
                        case FP_INFINITE: bits = traits::exponent | (t<0) * traits::sign; break;
                        case FP_SUBNORMAL: assert(std::numeric_limits<T>::has_denorm); // pass
                        case FP_ZERO: // note that floats can be ±0.0
                        case FP_NORMAL: traits::get_bits(t, bits); break;
                        default: throw portable_archive_exception(t);
                        }

                        save(bits);
                }

                // 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
                save(const T& t, dummy<4> = 0)
                {
                        // we provide a generic save 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
                        save((typename boost::uint_t<sizeof(T)*CHAR_BIT>::least)(t));
                }
        };

} // namespace eos

// required by export
#if BOOST_VERSION < 103500
#define BOOST_ARCHIVE_CUSTOM_OARCHIVE_TYPES eos::portable_oarchive
#else
BOOST_SERIALIZATION_REGISTER_ARCHIVE(eos::portable_oarchive)
#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_oarchive<eos::portable_oarchive>;

        template class basic_binary_oprimitive<
                eos::portable_oarchive
        #if BOOST_VERSION < 103400
                , std::ostream
        #else
                , std::ostream::char_type
                , std::ostream::traits_type
        #endif
        >;

#if (! _QX_USE_EXPORT_DLL_BOOST_SERIALIZATION_SINGLETON)
#if (BOOST_VERSION < 104000)
        template class detail::archive_pointer_oserializer<eos::portable_oarchive>;
#else // (BOOST_VERSION < 104000)
        template class detail::archive_serializer_map<eos::portable_oarchive>;
#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_OARCHIVE_H_
#endif // _QX_SERIALIZE_PORTABLE_BINARY
#endif // _QX_ENABLE_BOOST_SERIALIZATION