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

[zss]

Подскажите пожалуйста как можно
1. Сериализовать базовый класс
2. Как можно серелизовать контейнер. в котором хранятся указатели. Тоесть
2.1. Можно хранить умные указатели - тогда вроде прокатит
2.2. Можно ли без умных указателей сереализовать голый указатель ?

[BlackEmperor]

Классика жанра

Сообщение отредактировано: BlackEmperor - 05.03.07, 15:17

[zss]

BlackEmperor, что-то я не нашел там решения моих вопросов
только лишь

ПРЕДУПРЕЖДЕНИЕ
Опасно включать в карту указатели на какие-то объекты в памяти –
если объект сохраняется или передаётся по сети на другой компьютер,
то, скорее всего, после раскрутки буфера этот указатель будет указывать неизвестно куда,
а это никогда не приводило ни к чему хорошему.

Но от этого не легче И так было понятно что ничего не предпренимая сделать не удасться

Сообщение отредактировано: zss - 05.03.07, 16:04

[Hryak]

http://www.boost.org/libs/serialization/doc/tutorial.html

[zss]

1. C этим понятно

#include <boost/serialization/base_object.hpp>
 
class bus_stop_corner : public bus_stop
{
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // serialize base class information
        ar & boost::serialization::base_object<bus_stop>(*this);
        ar & street1;
        ar & street2;
    }
    std::string street1;
    std::string street2;
    virtual std::string description() const
    {
        return street1 + " and " + street2;
    }
public:
    bus_stop_corner(){}
    bus_stop_corner(const gps_position & lat_, const gps_position & long_,
        const std::string & s1_, const std::string & s2_
    ) :
        bus_stop(lat_, long_), street1(s1_), street2(s2_)
    {}
};

2. А вот это

class bus_route
{
    friend class boost::serialization::access;
    bus_stop * stops[10];
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        int i;
        for(i = 0; i < 10; ++i)
            ar & stops[i];
    }
public:
    bus_route(){}
};

и это

class bus_route
{
    friend class boost::serialization::access;
    bus_stop * stops[10];
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & stops;
    }
public:
    bus_route(){}
};

Получается, что он нормально их схавает ? А почему тогда в той статье что привел
BlackEmperor на это делается акцент ?

[Hryak]

Цитата zss @ 05.03.07, 16:20

Получается, что он нормально их схавает ?

Да.

Цитата

А почему тогда в той статье что привел
BlackEmperor на это делается акцент ?

Дык, ведь в той статье не про boost::serialization и говорится...

[zss]

Hryak

вот пример тестового кода

/* -------------------------------------------------------------------------- */
#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <fstream>
/* -------------------------------------------------------------------------- */
#ifdef _MSC_VER
# pragma warning (push)
# pragma warning (disable : 4267)
#endif
 
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
 
#ifdef _MSC_VER
# pragma warning (pop)
#endif
/* -------------------------------------------------------------------------- */
class Base : private boost::noncopyable {
private :
    int a;
 
    friend class boost::serialization::access;
 
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & BOOST_SERIALIZATION_NVP (a);
    }
 
protected :
    virtual int OnGet (void) const { return a; }
 
public :
    Base () : a (0) {;}
    explicit Base (int a) : a(a) {;}
    virtual ~Base () {;}
 
    int getA (void) const { return OnGet(); }
};
/* -------------------------------------------------------------------------- */
class Some : public Base {
private :
    int s;
 
    friend class boost::serialization::access;
 
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & boost::serialization::base_object<Base> (*this);
        archive & BOOST_SERIALIZATION_NVP (s);
    }
 
protected :
    virtual int OnGet (void) const { return Base::OnGet() + 1; }
 
public :
    Some () : Base (0), s(0) {;}
    Some (int a, int s) : Base (a), s(s) {;}
    virtual ~Some () {;}
 
    int getS (void) const { return s; }
};
/* -------------------------------------------------------------------------- */
int _tmain(int argc, _TCHAR* argv[])
{
    Some s (1, 2);
 
    std::ifstream ostream ("xxx.xml");
    if (ostream.is_open())
    {
        boost::archive::xml_iarchive archive (ostream);
        archive >> BOOST_SERIALIZATION_NVP (s);
    }
    ostream.close();
 
    Sleep (1000);
 
    std::ofstream istream ("xxx.xml");
    if (istream.is_open())
    {
        boost::archive::xml_oarchive archive (istream);
        archive << BOOST_SERIALIZATION_NVP (s);
    }
    istream.close();
 
    return 0;
}
/* -------------------------------------------------------------------------- */

вываливает

Compiling...
serialyze.cpp
c:\boost\boost\archive\detail\oserializer.hpp(131) : error C2027: use of undefined type 'boost::serialization::extended_type_info_null<T>'
        with
        [
            T=Some
        ]
        c:\boost\boost\archive\detail\oserializer.hpp(128) : while compiling class template member function 'bool boost::archive::detail::oserializer<Archive,T>::is_polymorphic(void) const'
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\boost\boost\archive\detail\oserializer.hpp(264) : see reference to class template instantiation 'boost::archive::detail::oserializer<Archive,T>' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\boost\boost\archive\detail\oserializer.hpp(263) : while compiling class template member function 'void boost::archive::detail::save_non_pointer_type<Archive,T>::save_standard::invoke(Archive &,const T &)'
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\boost\boost\archive\detail\oserializer.hpp(322) : see reference to class template instantiation 'boost::archive::detail::save_non_pointer_type<Archive,T>::save_standard' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\boost\boost\archive\detail\oserializer.hpp(310) : while compiling class template member function 'void boost::archive::detail::save_non_pointer_type<Archive,T>::invoke(Archive &,const T &)'
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\boost\boost\archive\detail\oserializer.hpp(536) : see reference to class template instantiation 'boost::archive::detail::save_non_pointer_type<Archive,T>' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\boost\boost\archive\basic_xml_oarchive.hpp(99) : see reference to function template instantiation 'void boost::archive::save<Archive,T>(Archive &,const T &)' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\boost\boost\archive\detail\interface_oarchive.hpp(78) : see reference to function template instantiation 'void boost::archive::basic_xml_oarchive<Archive>::save_override<Some>(const boost::serialization::nvp<T> &,int)' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
        c:\temp\serialyze\serialyze\serialyze.cpp(100) : see reference to function template instantiation 'Archive &boost::archive::detail::interface_oarchive<Archive>::operator <<<const boost::serialization::nvp<T>>(const boost::serialization::nvp<T> &)' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some
        ]
c:\boost\boost\archive\detail\oserializer.hpp(131) : error C2146: syntax error : missing ';' before identifier 'typex'
c:\boost\boost\archive\detail\oserializer.hpp(131) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
c:\boost\boost\archive\detail\oserializer.hpp(131) : error C2065: 'typex' : undeclared identifier
Build Time 0:02
Build log was saved at "file://c:\TEMP\serialyze\serialyze\Debug\BuildLog.htm"
serialyze - 4 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

что ему нужно ?

Сообщение отредактировано: zss - 13.03.07, 14:12

[Hryak]

Измени порядок включения хедеров:

#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/nvp.hpp>

и переделай сериализацию базового класса:

archive & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);

[zss]

Во как !!!!

И как же нам простым смертным все тонкости знать


Hryak не обижайся за назойливасть, но еще

/* -------------------------------------------------------------------------- */
#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <fstream>
#include <vector>
/* -------------------------------------------------------------------------- */
#ifdef _MSC_VER
# pragma warning (push)
# pragma warning (disable : 4267)
#endif
 
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/vector.hpp>
 
#ifdef _MSC_VER
# pragma warning (pop)
#endif
/* -------------------------------------------------------------------------- */
class Base : private boost::noncopyable {
private :
    typedef std::vector<std::pair<int, int> > VecType;
    VecType m_vec;
 
    friend class boost::serialization::access;
 
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & BOOST_SERIALIZATION_NVP (m_vec);
    }
 
 
public :
    Base  () {;}
    ~Base () {;}
};
/* -------------------------------------------------------------------------- */
class Some {
private :
    typedef std::vector <std::pair<int, Base *> > VecType;
    VecType m_vec;
 
    friend class boost::serialization::access;
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & BOOST_SERIALIZATION_NVP (m_vec);
    }
 
public :
    Some  () {;}
    ~Some () {;}
};
/* -------------------------------------------------------------------------- */
int _tmain(int argc, _TCHAR* argv[])
{
    Some s ();
 
    std::ifstream ostream ("xxx.xml");
    if (ostream.is_open())
    {
        boost::archive::xml_iarchive archive (ostream);
        archive >> BOOST_SERIALIZATION_NVP (s);
    }
    ostream.close();
 
    Sleep (1000);
 
    std::ofstream istream ("xxx.xml");
    if (istream.is_open())
    {
        boost::archive::xml_oarchive archive (istream);
        archive << BOOST_SERIALIZATION_NVP (s);
    }
    istream.close();
 
    return 0;
}

выдает

Compiling...
serialyze.cpp
c:\boost\boost\serialization\nvp.hpp(61) : warning C4180: qualifier applied to function type has no meaning; ignored
        c:\temp\serialyze\serialyze\serialyze.cpp(66) : see reference to class template instantiation 'boost::serialization::nvp<T>' being compiled
        with
        [
            T=Some (void)
        ]
c:\boost\boost\archive\detail\oserializer.hpp(567) : error C2027: use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'
        with
        [
            x=false
        ]
        c:\boost\boost\archive\basic_xml_oarchive.hpp(99) : see reference to function template instantiation 'void boost::archive::save<Archive,T>(Archive &,T (__cdecl &))' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some (void)
        ]
        c:\boost\boost\archive\detail\interface_oarchive.hpp(78) : see reference to function template instantiation 'void boost::archive::basic_xml_oarchive<Archive>::save_override<Some(void)>(const boost::serialization::nvp<T> &,int)' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some (void)
        ]
        c:\temp\serialyze\serialyze\serialyze.cpp(76) : see reference to function template instantiation 'Archive &boost::archive::detail::interface_oarchive<Archive>::operator <<<const boost::serialization::nvp<T>>(const boost::serialization::nvp<T> &)' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=Some (void)
        ]
c:\boost\boost\archive\detail\oserializer.hpp(568) : warning C4180: qualifier applied to function type has no meaning; ignored
Build Time 0:02
Build log was saved at "file://c:\TEMP\serialyze\serialyze\Debug\BuildLog.htm"
serialyze - 1 error(s), 2 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

[Hryak]

Цитата zss @ 13.03.07, 15:03

Hryak не обижайся за назойливасть, но еще

Обижаться не буду, но буду давать уклончивые ответы.

Цитата

    Some s ();

Вопрос на засыпку - что ты здесь такое объявил?

[zss]

Цитата Hryak @ 13.03.07, 16:13

Вопрос на засыпку - что ты здесь такое объявил?

получилась функция, возвращающая тип Some...

Попробовал сварить - получил

c:\boost\boost\serialization\access.hpp(109) : error C2039: 'serialize' : is not a member of 'std::pair<_Ty1,_Ty2>'
        with
        [
            _Ty1=int,
            _Ty2=Base *
        ]
        c:\boost\boost\serialization\serialization.hpp(81) : see reference to function template instantiation 'void boost::serialization::access::serialize<Archive,T>(Archive &,T &,const unsigned int)' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=const std::pair<int,Base *>
        ]
        c:\boost\boost\serialization\serialization.hpp(140) : see reference to function template instantiation 'void boost::serialization::serialize<Archive,T>(Archive &,T &,const unsigned int)' being compiled
        with
        [
            Archive=boost::archive::xml_oarchive,
            T=const std::pair<int,Base *>
        ]

Добавлено 13.03.07, 16:19
я так понял, что он не знаек как сериализовать std::pair<int, Base *>

Но я не нашел ничего подходящего для std::pair

[Hryak]

Цитата zss @ 13.03.07, 16:18

Но я не нашел ничего подходящего для std::pair

#include <boost/serialization/utility.hpp>

[zss]

Hryak - ты лучший

[zss]

Hryak, извини, но еще проблемка


как можно сериализовать интерфейс ? что-то не нравится ему...

тестовый код

/* -------------------------------------------------------------------------- */
#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <fstream>
#include <vector>
/* -------------------------------------------------------------------------- */
#ifdef _MSC_VER
# pragma warning (push)
# pragma warning (disable : 4267)
#endif
 
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/utility.hpp>
 
#ifdef _MSC_VER
# pragma warning (pop)
#endif
/* -------------------------------------------------------------------------- */
struct IBase
{
    virtual int get (void) const = 0;
    virtual ~IBase () = 0 {};
};
/* -------------------------------------------------------------------------- */
class Base : public IBase {
private :
    typedef std::vector<std::pair<int, int> > VecType;
    VecType m_vec;
 
    friend class boost::serialization::access;
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & BOOST_SERIALIZATION_BASE_OBJECT_NVP (IBase);
        archive & BOOST_SERIALIZATION_NVP (m_vec);
    }
 
 
public :
    Base  ()
    {
        m_vec.push_back(std::make_pair(1, 1));
    }
    ~Base () {;}
 
    virtual int get (void) const { return 1; }
};
/* -------------------------------------------------------------------------- */
class Some {
private :
    typedef std::vector <std::pair<int, IBase *> > VecType;
    VecType m_vec;
 
    friend class boost::serialization::access;
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & BOOST_SERIALIZATION_NVP (m_vec);
    }
 
public :
    Some  ()
    {
        m_vec.push_back(std::make_pair (100, new Base()));
    }
    ~Some () {;}
};
/* -------------------------------------------------------------------------- */
int _tmain(int argc, _TCHAR* argv[])
{
    Some s;
 
    std::ofstream istream ("xxx.xml");
    if (istream.is_open())
    {
        boost::archive::xml_oarchive archive (istream);
        archive << BOOST_SERIALIZATION_NVP (s);
    }
    istream.close();
 
    Sleep (1000);
 
    std::ifstream ostream ("xxx.xml");
    if (ostream.is_open())
    {
        boost::archive::xml_iarchive archive (ostream);
        archive >> BOOST_SERIALIZATION_NVP (s);
    }
    ostream.close();
 
    return 0;
}
/* -------------------------------------------------------------------------- */

[Hryak]

Цитата zss @ 20.03.07, 18:16

что-то не нравится ему...

Чего не нравится? Как ругается?

[zss]

Цитата Hryak @ 20.03.07, 19:25

Чего не нравится? Как ругается?

да он собирается без ошибок и предупреждений. Но вот при выполнении вываливает при сериализацции

typedef std::vector <std::pair<int, IBase *> > VecType;

тоесть пары, содержащей интерфейс

Unhandled exception at 0x7c81eb33 in serialyze.exe: Microsoft C++ exception: boost::archive::archive_exception at memory location 0x0012d640..

посмотрел в отладке на

template<class E> inline void throw_exception(E const & e)
{
    throw e;
}

который бросается, так вот код вроде = unregistered_cast

[Hryak]

Цитата zss @ 21.03.07, 04:17

код вроде = unregistered_cast

Ты сериализируешь производный класс по указателю на базовый. Помочь бусту нужно - пропиши в началале Some::serialize строчку:

archive.register_type(static_cast<Base*>(NULL));

[zss]

Hryak, я тут немного изврвщаюсь и опять не пойму, что от меня хочет boost.
Есть подозрение, что что-то с типами не так

это устройство для контейнера

template<typename Container>
class rcontainer /*: public boost::iostreams::source*/ {
private:
    typedef typename Container::size_type   size_type;
    const Container&    m_container;
    size_type           m_index;
 
public:
    typedef typename Container::value_type  char_type;
    typedef boost::iostreams::source_tag    category;
 
    rcontainer (const Container& container) : m_container(container), m_index(0) {}
    ~rcontainer () {}
 
    std::streamsize read (char_type* value, std::streamsize size)
    {
        std::streamsize delta = static_cast<std::streamsize> (
            m_container.size() - m_index
        );
 
        std::streamsize result = std::min<std::streamsize> (size, delta);
        if (!result) return -1;
 
        std::copy (
            m_container.begin() + m_index,
            m_container.begin() + m_index + result, value
        );
        m_index += result;
        return result;
    }
};
 
template<typename Container>
class wcontainer /*: public boost::iostreams::sink*/ {
private:
    Container& m_container;
 
public:
    typedef typename Container::value_type  char_type;
    typedef boost::iostreams::sink_tag      category;
 
    wcontainer (Container& container) : m_container(container) {}
    ~wcontainer () {}
 
    std::streamsize write (const char_type* value, std::streamsize size)
    {
        m_container.insert (m_container.end(), value, value + size);
        return size;
    }
};

Это сериализация

    typedef std::vector<char> sbuffer;
    typedef rcontainer <sbuffer> rdevice;
    typedef wcontainer <sbuffer> wdevice;
 
 
    template <class T>
    inline void serialize (sbuffer& buffer, const T& rhs)
    {
        try
        {
            namespace bio = boost::iostreams;
 
            wdevice device (buffer);
            bio::stream_buffer<wdevice> stream (device);
            //std::basic_ostream <unsigned char> ostream (&stream);
            std::ostream ostream (&stream);
 
            boost::archive::binary_oarchive archive (ostream);
            archive << BOOST_SERIALIZATION_NVP (rhs);
        }
        catch (std::exception& ex)
        {
            std::cerr << ex.what() << std::endl;
        }
    }
 
    template <class T>
    inline void deserialize (const sbuffer& buffer, T& rhs)
    {
        try
        {
            namespace bio = boost::iostreams;
 
            rdevice device (buffer);
            bio::stream_buffer<rdevice> stream (device);
            //std::basic_istream <unsigned char> istream (&stream);
            std::istream istream (&stream);
 
            boost::archive::binary_iarchive archive (istream);
            archive >> BOOST_SERIALIZATION_NVP (rhs);
        }
        catch (std::exception& ex)
        {
            std::cerr << ex.what() << std::endl;
        }
    }

он предупреждает

C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(2282) : warning C4996: 'std::_Copy_opt' was declared deprecated
        C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(2270) : see declaration of 'std::_Copy_opt'
        Message: 'You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library'
        e:\wcl\stream.h(97) : see reference to function template instantiation '_OutIt std::copy<std::_Vector_const_iterator<_Ty,_Alloc>,char*>(_InIt,_InIt,_OutIt)' being compiled
        with
        [
            _OutIt=char *,
            _Ty=char,
            _Alloc=std::allocator<char>,
            _InIt=std::_Vector_const_iterator<char,std::allocator<char>>
        ]
        e:\wcl\stream.h(86) : while compiling class template member function 'std::streamsize rcontainer<Container>::read(char *,std::streamsize)'
        with
        [
            Container=parser::sbuffer
        ]
        e:\\wcl\parser.h(200) : see reference to class template instantiation 'rcontainer<Container>' being compiled
        with
        [
            Container=parser::sbuffer
        ]
        .\data.cpp(121) : see reference to function template instantiation 'void parser::deserialize<Channels>(const parser::sbuffer &,T &)' being compiled
        with
        [
            T=Channels
        ]

Что он хочет ?

Сообщение отредактировано: zss - 14.06.07, 16:22

[Hryak]

Цитата zss @ 14.06.07, 16:19

Что он хочет ?

M$ only.
std::copy на сырых указателях (не итераторах) M$ объявило опасным. Рекомендуется предварительно преобразовывать сырой указатель в checked_array_iterator.

Сообщение отредактировано: Hryak - 14.06.07, 16:33

[zss]

Цитата Hryak @ 14.06.07, 16:32

M$ only.
std::copy на сырых указателях (не итераторах) M$ объявило опасными. Рекомендуется предварительно преобразовывать сырой указатель в checked_array_iterator.

stdext::checked_array_iterator<char *> (...)

Это ?

[Hryak]

Да. В MSDN есть примеры с пояснениями - понятно, что к чему.

[zss]

тоесть ты хочешь сказать, что это предупреждение относится толко к методу read

получится что-то вроде

    std::streamsize read (char_type* value, std::streamsize size)
    {
        std::streamsize delta = static_cast<std::streamsize> (
            m_container.size() - m_index
        );
 
        std::streamsize result = std::min<std::streamsize> (size, delta);
        if (!result) return -1;
 
        std::copy (
            m_container.begin() + m_index,
            m_container.begin() + m_index + result,
            stdext::checked_array_iterator<char_type *> (value)
        );
        m_index += result;
        return result;
    }

[Hryak]

Цитата zss @ 14.06.07, 16:38

тоесть ты хочешь сказать, что это предупреждение относится толко к методу read

По тексту сообщения так получается. Компилировать я не пытался.

Цитата

получится что-то вроде

Не совсем. Суть во втором параметре конструктора этого итератора. А у тебя его нет. Пропиши туда количество копируемых символов

[zss]

Цитата Hryak @ 14.06.07, 16:46

Не совсем. Суть во втором параметре конструктора этого итератора. А у тебя его нет. Пропиши туда количество копируемых символов

так для read

        std::streamsize result = std::min<std::streamsize> (size, delta);
        if (!result) return -1;
 
        std::copy (
            m_container.begin() + m_index,
            m_container.begin() + m_index + result,
            stdext::checked_array_iterator<char_type *> (value, relult)
        );

а для write у меня диапазон. Тоесть первый checked_array_iterator размером 0 ?

        m_container.insert (
            m_container.end(),
            stdext::checked_array_iterator<const char_type *> (value, 0),
            stdext::checked_array_iterator<const char_type *> (value, size));

Добавлено 14.06.07, 16:53
что-то это не избавило от варнинга

Сообщение отредактировано: zss - 14.06.07, 16:56

[Hryak]

Цитата zss @ 14.06.07, 16:50

а для write у меня диапазон. Тоесть первый

insert не трогай.

Цитата

что-то это не избавило от варнинга

И эта строчка осталась на месте?

while compiling class template member function 'std::streamsize rcontainer<Container>::read(char *,std::streamsize)'

Сообщение отредактировано: Hryak - 14.06.07, 17:02

[zss]

Цитата Hryak @ 14.06.07, 17:01

И эта строчка осталась на месте?

не - исчезла гадина

осталось только это

C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(241) : warning C4996: 'std::char_traits<char>::move' was declared deprecated
        C:\Program Files\Microsoft Visual Studio 8\VC\include\iosfwd(470) : see declaration of 'std::char_traits<char>::move'
        Message: 'You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library'
        C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(230) : while compiling class template member function 'int boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>::underflow(void)'
        with
        [
            T=parser::wdevice,
            Tr=std::char_traits<char>,
            Alloc=std::allocator<char>,
            Mode=boost::iostreams::detail::io_mode_impl<2>::type
        ]
        C:\boost\boost/iostreams/stream_buffer.hpp(64) : see reference to class template instantiation 'boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>' being compiled
        with
        [
            T=parser::wdevice,
            Tr=std::char_traits<char>,
            Alloc=std::allocator<char>,
            Mode=boost::iostreams::detail::io_mode_impl<2>::type
        ]
        e:\wcl\parser.h(179) : see reference to class template instantiation 'boost::iostreams::stream_buffer<T>' being compiled
        with
        [
            T=parser::wdevice
        ]
        .\data.cpp(104) : see reference to function template instantiation 'void parser::serialize<Channels>(parser::sbuffer &,const T &)' being compiled
        with
        [
            T=Channels
        ]

[zss]

В общем я так и не понят почему boost ругается и пришлось отключить варнинг... (не очень правда это хорошо как мне кажется)

Есть еще вопросик

class Object;
typedef std::list<Object> TList;
 
class Owner {
private :
    friend class boost::serialization::access;
 
    int a;
    int b;
    TList list;
 
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & BOOST_SERIALIZATION_NVP (list);
    }
 
public :
    Owner () {}
    ~Owner() {}
}

я сериализую Owner. Реально сериализуется лишь только список.
Отправляю данные. Могу ли я на другой стороне десериализовать сразу в TList или я обязан десериализовать в Owner ?

Аналогично в обратную сторону. Я получил TList, подправил некоторые данные и хочу отправить их обратно.
Естественно сериализую я список. Могу ли я его десериализовать в Owner ?

[zss]

ну где же ты, Hryak

[zss]

хочу сериализовать класс

template <typename T, class Container = std::deque <T> >
class Queue {
private :
    friend class boost::serialization::access;
 
    std::queue <T, Container> m_queue;
 
    template <class Archive>
    void serialize (Archive& archive, const unsigned int version)
    {
        archive & BOOST_SERIALIZATION_NVP (m_queue);
    }
 
public :
    Queue () {}
    ~Queue() {}
};

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

[zss]

никто не сериализовал ?

[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, а не его временную копию. Тогда копирования можно избежать.
Правда нарушится сигнатура метода...