StlSerializationOperators.h

Go to the documentation of this file.

// StlSerializationOperators.h:
// ----------------------------
//

#ifndef __IPSDKSERIALIZATION_STLSERIALIZATIONOPERATORS_H__
#define __IPSDKSERIALIZATION_STLSERIALIZATIONOPERATORS_H__

#include <IPSDKSerialization/IPSDKSerializationExports.h>
#include <IPSDKSerialization/Archive/BaseIArchive.h>
#include <IPSDKSerialization/Archive/BaseOArchive.h>
#include <IPSDKSerialization/Engine/BasicSerializationOperators.h>
#include <IPSDKSerialization/Engine/SerializationIItemMacros.h>
#include <IPSDKSerialization/Engine/SerializationOItemMacros.h>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/is_same.hpp>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <deque>

namespace ipsdk {



template <class T>
typename boost::enable_if_c<boost::is_arithmetic<T>::value == false,
                            BaseIArchive&>::type
operator>> (BaseIArchive& ar, const SerializationIItem<std::vector<T> >& item)
{
    // retrieve input collection
    std::vector<T>& coll = item._value;

    // clear of input collection
    coll.clear();

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

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

    // serialization of collection size
    ipUInt32 size;
    ar >> IPSDK_MAKE_IITEM_VALUE(size);
    coll.resize(size);

    // serialization of collection data
    typename std::vector<T>::iterator iter = coll.begin();
    while (iter != coll.end()) {

        T& value = *iter;
        ar >> IPSDK_MAKE_IITEM_VALUE(value);

        ++iter;
    }

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

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

    return ar;
}

template <class T>
typename boost::enable_if_c<boost::is_arithmetic<T>::value == true &&
                            boost::is_same<T, bool>::value == false,
                            BaseIArchive&>::type
operator>> (BaseIArchive& ar, const SerializationIItem<std::vector<T> >& item)
{
    // retrieve input collection
    std::vector<T>& coll = item._value;

    // clear of input collection
    coll.clear();

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

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

    // serialization of collection size
    ipUInt32 size;
    ar >> IPSDK_MAKE_IITEM_VALUE(size);
    coll.resize(size);

    // serialization of collection data
    if (ar.isTextArchive() == false)
        ar.read(coll.data(), size * sizeof(T));
    else {

        typename std::vector<T>::iterator iter = coll.begin();
        while (iter != coll.end()) {

            T& value = *iter;
            ar >> IPSDK_MAKE_IITEM_VALUE(value);

            ++iter;
        }
    }

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

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

    return ar;
}

template <class T>
typename boost::enable_if_c<boost::is_same<T, ipBool>::value == true,
                            BaseIArchive&>::type
operator>> (BaseIArchive& ar, const SerializationIItem<std::vector<T> >& item)
{
    // retrieve input collection
    std::vector<T>& coll = item._value;

    // clear of input collection
    coll.clear();

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

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

    // serialization of collection size
    ipUInt32 size;
    ar >> IPSDK_MAKE_IITEM_VALUE(size);
    coll.resize(size);

    // serialization of collection data
    typename std::vector<T>::iterator iter = coll.begin();
    while (iter != coll.end()) {

        T value;
        ar >> IPSDK_MAKE_IITEM_VALUE(value);
        *iter = value;

        ++iter;
    }

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

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

    return ar;
}

template <class T>
typename boost::enable_if_c<boost::is_arithmetic<T>::value == false ||
                            boost::is_same<T, ipBool>::value == true,
                            BaseOArchive&>::type
operator<< (BaseOArchive& ar, const SerializationOItem<std::vector<T> >& item)
{
    // retrieve input collection
    const std::vector<T>& coll = item._value;

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

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

    // serialization of collection size
    ipUInt32 size = static_cast<ipUInt32>(coll.size());
    ar << IPSDK_MAKE_OITEM_VALUE(size);

    // serialization of collection data
    typename std::vector<T>::const_iterator iter = coll.begin();
    while (iter != coll.end()) {

        const T& value = *iter;
        ar << IPSDK_MAKE_OITEM_VALUE(value);
        ++iter;
    }

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

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

    return ar;
}

template <class T>
typename boost::enable_if_c<boost::is_arithmetic<T>::value == true &&
                            boost::is_same<T, ipBool>::value == false,
                            BaseOArchive&>::type
operator<< (BaseOArchive& ar, const SerializationOItem<std::vector<T> >& item)
{
    // retrieve input collection
    const std::vector<T>& coll = item._value;

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

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

    // serialization of collection size
    ipUInt32 size = static_cast<ipUInt32>(coll.size());
    ar << IPSDK_MAKE_OITEM_VALUE(size);

    // serialization of collection data
    if (ar.isTextArchive() == false)
        ar.write(coll.data(), size * sizeof(T));
    else {

        typename std::vector<T>::const_iterator iter = coll.begin();
        while (iter != coll.end()) {

            const T& value = *iter;
            ar << IPSDK_MAKE_OITEM_VALUE(value);
            ++iter;
        }
    }

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

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

    return ar;
}


template <class T>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<std::list<T> >& item)
{
    // retrieve input collection
    std::list<T>& coll = item._value;

    // clear of input collection
    coll.clear();

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

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

    // serialization of collection size
    ipUInt32 size;
    ar >> IPSDK_MAKE_IITEM_VALUE(size);
    coll.resize(size);

    // serialization of collection data
    typename std::list<T>::iterator iter = coll.begin();
    while (iter != coll.end()) {

        T& value = *iter;
        ar >> IPSDK_MAKE_IITEM_VALUE(value);

        ++iter;
    }

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

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

    return ar;
}

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

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

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

    // serialization of collection size
    ipUInt32 size = static_cast<ipUInt32>(coll.size());
    ar << IPSDK_MAKE_OITEM_VALUE(size);

    // serialization of collection data
    typename std::list<T>::const_iterator iter = coll.begin();
    while (iter != coll.end()) {

        const T& value = *iter;
        ar << IPSDK_MAKE_OITEM_VALUE(value);
        ++iter;
    }

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

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

    return ar;
}




template <class Key, class Value>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<std::map<Key, Value> >& item)
{
    // retrieve input collection
    std::map<Key, Value>& coll = item._value;

    // clear of input collection
    coll.clear();

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

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

    // serialization of collection size
    ipUInt32 size;
    ar >> IPSDK_MAKE_IITEM_VALUE(size);

    // serialization of collection data
    for (ipUInt32 i=0; i<size; ++i) {
        
        Key key;
        Value value;
        ar >> IPSDK_MAKE_IITEM_VALUE(key);
        ar >> IPSDK_MAKE_IITEM_VALUE(value);
        coll[key] = value;
    }

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

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

    return ar;
}

template <class Key, class Value>
BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<std::map<Key, Value> >& item)
{
    // retrieve input collection
    const std::map<Key, Value>& coll = item._value;

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

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

    // serialization of collection size
    ipUInt32 size = static_cast<ipUInt32>(coll.size());
    ar << IPSDK_MAKE_OITEM_VALUE(size);

    // serialization of collection data
    typename std::map<Key, Value>::const_iterator iter = coll.begin();
    while (iter != coll.end()) {

        const Key& key = iter->first;
        const Value& value = iter->second;
        ar << IPSDK_MAKE_OITEM_VALUE(key);
        ar << IPSDK_MAKE_OITEM_VALUE(value);

        ++iter;
    }

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

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

    return ar;
}




template <class T>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<std::set<T> >& item)
{
    // retrieve input collection
    std::set<T>& coll = item._value;

    // clear of input collection
    coll.clear();

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

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

    // serialization of collection size
    ipUInt32 size;
    ar >> IPSDK_MAKE_IITEM_VALUE(size);

    // serialization of collection data
    for (ipUInt32 i=0; i<size; ++i) {
        
        T key;
        ar >> IPSDK_MAKE_IITEM_VALUE(key);
        coll.insert(key);
    }

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

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

    return ar;
}

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

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

    // serialization of collection size
    ipUInt32 size = static_cast<ipUInt32>(coll.size());
    ar << IPSDK_MAKE_OITEM_VALUE(size);

    // serialization of collection data
    typename std::set<T>::const_iterator iter = coll.begin();
    while (iter != coll.end()) {

        const T& key = *iter;
        ar << IPSDK_MAKE_OITEM_VALUE(key);

        ++iter;
    }

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

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

    return ar;
}



template <class T>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<std::deque<T> >& item)
{
    // retrieve input collection
    std::deque<T>& coll = item._value;

    // clear of input collection
    coll.clear();

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

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

    // serialization of collection size
    ipUInt32 size;
    ar >> IPSDK_MAKE_IITEM_VALUE(size);
    coll.resize(size);

    // serialization of collection data
    typename std::deque<T>::iterator iter = coll.begin();
    while (iter != coll.end()) {

        T& value = *iter;
        ar >> IPSDK_MAKE_IITEM_VALUE(value);

        ++iter;
    }

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

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

    return ar;
}

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

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

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

    // serialization of collection size
    ipUInt32 size = static_cast<ipUInt32>(coll.size());
    ar << IPSDK_MAKE_OITEM_VALUE(size);

    // serialization of collection data
    typename std::deque<T>::const_iterator iter = coll.begin();
    while (iter != coll.end()) {

        const T& value = *iter;
        ar << IPSDK_MAKE_OITEM_VALUE(value);
        ++iter;
    }

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

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

    return ar;
}



template <class T, class U>
BaseIArchive&
operator>> (BaseIArchive& ar, const SerializationIItem<std::pair<T, U> >& item)
{
    // retrieve input collection
    std::pair<T, U>& p = item._value;

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

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

    T first;
    U second;

    ar >> IPSDK_MAKE_IITEM_VALUE(first);
    ar >> IPSDK_MAKE_IITEM_VALUE(second);

    p.first = first;
    p.second = second;

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

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

    return ar;
}

template <class T, class U>
BaseOArchive&
operator<< (BaseOArchive& ar, const SerializationOItem<std::pair<T, U> >& item)
{
    // retrieve input collection
    const std::pair<T, U>& p = item._value;

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

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

    const T& first = p.first;
    const U& second = p.second;

    ar << IPSDK_MAKE_OITEM_VALUE(first);
    ar << IPSDK_MAKE_OITEM_VALUE(second);

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

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

    return ar;
}



} // end of namespace ipsdk

#endif // __IPSDKSERIALIZATION_STLSERIALIZATIONOPERATORS_H__