BoostSerializationOperators.h

Go to the documentation of this file.

// BoostSerializationOperators.h:
// ------------------------------
//

#ifndef __IPSDKSERIALIZATION_BOOSTSERIALIZATIONOPERATORS_H__
#define __IPSDKSERIALIZATION_BOOSTSERIALIZATIONOPERATORS_H__

#include <IPSDKSerialization/IPSDKSerializationExports.h>
#include <IPSDKSerialization/Engine/BasicSerializationOperators.h>
#include <IPSDKSerialization/Engine/SerializationOItemMacros.h>
#include <IPSDKSerialization/Engine/SerializationIItemMacros.h>
#include <IPSDKSerialization/Archive/BaseIArchive.h>
#include <IPSDKSerialization/Archive/BaseOArchive.h>
#include <boost/filesystem/path.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/optional.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <boost/type_traits/remove_const.hpp>

namespace ipsdk {


IPSDKSERIALIZATION_API BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<boost::filesystem::path>& item);
IPSDKSERIALIZATION_API BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<boost::filesystem::path>& item);

IPSDKSERIALIZATION_API BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<boost::gregorian::date>& item);
IPSDKSERIALIZATION_API BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<boost::gregorian::date>& item);

IPSDKSERIALIZATION_API BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<boost::posix_time::ptime>& item);
IPSDKSERIALIZATION_API BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<boost::posix_time::ptime>& item);

template <class T>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<boost::optional<T> >& item)
{
    // retrieve input optional
    boost::optional<T>& opt = item._value;

    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, item._itemName);

    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, "optional");

    bool bInit;
    ar >> IPSDK_MAKE_IITEM_VALUE(bInit);
    if(bInit) {
        T value;
        ar >> IPSDK_MAKE_IITEM_VALUE(value);
        opt = value;
    }
    else {
        opt = boost::none;
    }

    // end archive section
    IPSDK_END_ARCHIVE_SECTION("optional");

    // end archive section
    IPSDK_END_ARCHIVE_SECTION(item._itemName);

    return ar;
}

template <class T>
BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<boost::optional<T> >& item)
{
    // retrieve input collection
    const boost::optional<T>& opt = item._value;

    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, item._itemName);
    
    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, "optional");

    const bool bInit = opt.is_initialized();
    ar << IPSDK_MAKE_OITEM_VALUE(bInit);
    if(bInit) {
        const T& value = opt.get();
        ar << IPSDK_MAKE_OITEM_VALUE(value);
    }

    // end archive section
    IPSDK_END_ARCHIVE_SECTION("optional");

    // end archive section
    IPSDK_END_ARCHIVE_SECTION(item._itemName);

    return ar;
}




template <class T>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<boost::shared_ptr<T> >& item)
{
    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, item._itemName);

    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, "shared_ptr<>");

    // serialize base shared pointer
    SerializationObjectPtr pObject;
    ar.read(IPSDK_MAKE_IITEM_VALUE(pObject));

    // update of derived one
    item._value = boost::static_pointer_cast<T>(pObject);

    // end archive section
    IPSDK_END_ARCHIVE_SECTION("shared_ptr<>");

    // end archive section
    IPSDK_END_ARCHIVE_SECTION(item._itemName);

    return ar;
}

template <class T>
BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<boost::shared_ptr<T> >& item)
{
    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, item._itemName);

    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, "shared_ptr<" + T::getTypeName() + ">");

    // retrieve base shared pointer
    SerializationObjectConstPtr pObject = item._value;

    // serialize it
    ar.write(IPSDK_MAKE_OITEM_VALUE(pObject));

    // end archive section
    IPSDK_END_ARCHIVE_SECTION("shared_ptr<" + T::getTypeName() + ">");

    // end archive section
    IPSDK_END_ARCHIVE_SECTION(item._itemName);

    return ar;
}



IPSDKSERIALIZATION_API void
reportVariantSerializationError(const int expectedTypeId,
                                const std::string& typeSeqStr);

template <typename Sequence>
struct VariantLoadManager
{
    struct NullLoad {

        template<class VariantType>
        static void apply(BaseIArchive& ar, int which, VariantType& v)
        {}
    };

    struct IterLoad {

        template<class VariantType>
        static void apply(BaseIArchive& ar, int which, VariantType& v)
        {
            if(which == 0){

                typedef typename boost::mpl::front<Sequence>::type head_type;
                head_type value;
                ar >> IPSDK_MAKE_IITEM_VALUE(value);
                v = value;
            }
            else {

                typedef typename boost::mpl::pop_front<Sequence>::type type;
                VariantLoadManager<type>::load(ar, which - 1, v);
            }
        }
    };

    template<class VariantType>
    static void load(BaseIArchive& ar, int which, VariantType& v) {

        typedef typename boost::mpl::eval_if<boost::mpl::empty<Sequence>,
            boost::mpl::identity<IterLoad>,
            boost::mpl::identity<NullLoad>
        >::type typex;
        typex::apply(ar, which, v);
    }
};

template <BOOST_VARIANT_ENUM_PARAMS(class T)>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >& item)
{
    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, item._itemName);

    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, "variant");

    // serialize variant subtype
    int which;
    ar >> IPSDK_MAKE_IITEM_VALUE(which);

    // check for which validity
    typedef typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
    if(which >= boost::mpl::size<types>::value)
        reportVariantSerializationError(which, BOOST_PP_STRINGIZE((BOOST_VARIANT_ENUM_PARAMS(T))));

    // load variant value
    VariantLoadManager<types>::load(ar, which, item._value);

    // end archive section
    IPSDK_END_ARCHIVE_SECTION("variant");

    // end archive section
    IPSDK_END_ARCHIVE_SECTION(item._itemName);

    return ar;
}

struct VariantSaveVisitor : boost::static_visitor<> 
{
    VariantSaveVisitor(BaseOArchive& ar) :
        _ar(ar)
    {}

    template<class T>
    void operator()(T const & value) const
    {
        _ar << IPSDK_MAKE_OITEM_VALUE(value);
    }

private:
    BaseOArchive& _ar;
};

template <BOOST_VARIANT_ENUM_PARAMS(class T)>
BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >& item)
{
    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, item._itemName);
    
    // start a new archive section
    IPSDK_START_ARCHIVE_SECTION(ar, "variant");

    // serialize variant subtype
    const int which = item._value.which();
    ar << IPSDK_MAKE_OITEM_VALUE(which);

    // serialization of variant value
    VariantSaveVisitor visitor(ar);
    item._value.apply_visitor(visitor);
    
    // end archive section
    IPSDK_END_ARCHIVE_SECTION("variant");

    // end archive section
    IPSDK_END_ARCHIVE_SECTION(item._itemName);

    return ar;
}



} // end of namespace ipsdk

#endif // __IPSDKSERIALIZATION_BOOSTSERIALIZATIONOPERATORS_H__