сереализация , boost::serialization

[zss]

похоже начался сезон отпусков

[zss]

тема поднимается заново. Я так и не смог сериализовать std::queue.
Так все-таки это возможно ли нет ?

[SL555]

Возможно, я это делаю правдо без буста вот тут пример
[C++] Сериализация

посмотри как происходит сериализация std::map и std::vector

[zss]

у меня на бусте все заточено

[Hryak]

Цитата zss @ 27.06.07, 16:53

Но что-то не нашел в boost/serialization ничего подходящего для сериализации std::queue.

А в boost\serialization\deque.hpp чего лежит?

[zss]

Цитата Hryak @ 19.07.07, 17:09

А в boost\serialization\deque.hpp чего лежит?

там лежит код для deque. а мне нужен для queue

[Hryak]

Цитата zss @ 19.07.07, 20:14

там лежит код для deque. а мне нужен для queue

Мдя. Взгляд ухватился за "class Container = std::deque <T>", а дальше глаз замылился...

Естественно, для сериализации queue в бусте нет готового решения, поскольку этот контейнер (наряду с priority_queue и stack) не такой, как остальные - он всего лишь надстройка над другим контейнером и нельзя прочитать все элементы очереди, не уничтожив их.
Можешь или сам написать сериализацию очереди (копируешь очередь в новую очередь и её поэлементно записываешь в архив), если тебе это подходит, или отказываешься от очереди.

[zss]

Цитата Hryak @ 20.07.07, 02:46

Естественно, для сериализации queue в бусте нет готового решения, поскольку этот контейнер (наряду с priority_queue и stack) не такой, как остальные - он всего лишь надстройка над другим контейнером и нельзя прочитать все элементы очереди, не уничтожив их.
Можешь или сам написать сериализацию очереди (копируешь очередь в новую очередь и её поэлементно записываешь в архив), если тебе это подходит, или отказываешься от очереди

тоесть не строить не queue, а сразу использовать deque ? А правильно ли это (если конечно разумно с queue использовать другие контейнеры)

Добавлено 20.07.07, 09:22
предложили вот такой вариант, только меня смущает копирование в методе save_queue

#ifndef BOOST_SERIALIZATION_QUEUE_HPP
#define BOOST_SERIALIZATION_QUEUE_HPP
 
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
 
#include <queue>
 
#include <boost/config.hpp>
 
#include <boost/serialization/collections_save_imp.hpp>
#include <boost/serialization/collections_load_imp.hpp>
#include <boost/serialization/split_free.hpp>
 
#include "queue_save_imp.hpp"
 
// function specializations must be defined in the appropriate
// namespace - boost::serialization
#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
#define STD _STLP_STD
#else
#define STD std
#endif
 
namespace boost {
    namespace serialization {
        namespace stl {
 
template<class Archive, class Container>
struct archive_input_queue
{
    inline void operator()(Archive &ar, Container &s)
    {
        detail::stack_construct<Archive, BOOST_DEDUCED_TYPENAME Container::value_type> t(ar);
        // borland fails silently w/o full namespace
        ar >> boost::serialization::make_nvp("item", t.reference());
        s.push(t.reference());
        ar.reset_object_address(& s.back() , & t.reference());
    }
};
        }
    }
}
 
namespace boost {
    namespace serialization {
 
        template<class Archive, class U, class Allocator>
        inline void save(
            Archive & ar,
            const STD::queue<U, Allocator> &t,
            const unsigned int /* file_version */
            ){
                boost::serialization::stl::save_queue<
                    Archive,
                    std::queue<U, Allocator>
                >(ar, t);
        }
 
        template<class Archive, class U, class Allocator>
        inline void load(
            Archive & ar,
            STD::queue<U, Allocator> &t,
            const unsigned int /* file_version */
            ){
                boost::serialization::stl::load_queue<
                    Archive,
                    std::queue<U, Allocator>,
                    boost::serialization::stl::archive_input_queue<
                    Archive,
                    std::queue<U, Allocator>
                    >,
                    boost::serialization::stl::no_reserve_imp<STD::queue<U, Allocator> >
                >(ar, t);
        }
 
        // split non-intrusive serialization function member into separate
        // non intrusive save/load member functions
        template<class Archive, class U, class Allocator>
        inline void serialize(
            Archive & ar,
            STD::queue<U, Allocator> & t,
            const unsigned int file_version
            ){
                boost::serialization::split_free(ar, t, file_version);
        }
 
    } // serialization
} // namespace boost
 
#include <boost/serialization/collection_traits.hpp>
 
BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::queue)
#undef STD
 
#endif // BOOST_SERIALIZATION_LIST_HPP
 
 
#ifndef BOOST_QUEUE_SAVE_IMP_HPP
#define BOOST_QUEUE_SAVE_IMP_HPP
 
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
 
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/serialization.hpp>
 
namespace boost{
    namespace serialization {
        namespace stl {
 
 
            //////////////////////////////////////////////////////////////////////
            // implementation of serialization for STL containers
            //
 
            template<class Archive, class Container>
            inline void save_queue(Archive & ar, const Container &s)
            {
                // record number of elements
                unsigned int count = s.size();
                ar << make_nvp("count", const_cast<const unsigned int &>(count));
                //BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin();
 
                //make copy of queue
                Container tmp = s;
 
                while(!tmp.empty())
                {
                    boost::serialization::save_construct_data_adl(ar, &(tmp.front()), 0U);
                    ar << boost::serialization::make_nvp("item", tmp.front());
                    tmp.pop();
                }
            }
 
            template<class Archive, class Container, class InputFunction, class R>
            inline void load_queue(Archive & ar, Container &s)
            {
                while(!s.empty()) s.pop();
 
                // retrieve number of elements
                unsigned int count;
                ar >> BOOST_SERIALIZATION_NVP(count);
                R rx;
                rx(s, count);
                InputFunction ifunc;
                while(count-- > 0){
                    ifunc(ar, s);
                }
 
            }
 
 
        } // namespace stl
    } // namespace serialization
} // namespace boost
 
#endif //BOOST_QUEUE_SAVE_IMP_HPP

[Hryak]

Цитата zss @ 20.07.07, 08:51

А правильно ли это (если конечно разумно с queue использовать другие контейнеры)

Если тебя не устраивает копирование очереди при сериализации - это единственное, что ты можешь сделать. Правильность-неправильность побоку.

Цитата

предложили вот такой вариант, только меня смущает копирование в методе save_queue

Смущает? Я тебе еще утром сказал, что только с копированием очереди её элементы можно сериализовать.

[zss]

Цитата Hryak @ 20.07.07, 15:38

Если тебя не устраивает копирование очереди при сериализации - это единственное, что ты можешь сделать. Правильность-неправильность побоку.

Цитата Hryak @ 20.07.07, 15:38

Смущает? Я тебе еще утром сказал, что только с копированием очереди её элементы можно сериализовать.

ну почему - можно же save_queue изменять сразу s, а не его временную копию. Тогда копирования можно избежать.
Правда нарушится сигнатура метода...