Форум на Исходниках.RU

сереализация

zss — Fri, 20 Jul 2007 19:26:49 +0000

zss:

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

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

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

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

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

сереализация

Hryak — Fri, 20 Jul 2007 15:38:20 +0000

Hryak:

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

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

Цитата

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

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

сереализация

zss — Fri, 20 Jul 2007 08:51:17 +0000

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 — Fri, 20 Jul 2007 02:46:53 +0000

Hryak:

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

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

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

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

сереализация

zss — Thu, 19 Jul 2007 20:14:37 +0000

zss:

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

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

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

сереализация

Hryak — Thu, 19 Jul 2007 17:09:08 +0000

Hryak:

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

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

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

сереализация

zss — Thu, 19 Jul 2007 12:41:56 +0000

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

сереализация

SL555 — Thu, 19 Jul 2007 12:22:41 +0000

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

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

сереализация

zss — Thu, 19 Jul 2007 11:28:13 +0000

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

сереализация

zss — Sat, 30 Jun 2007 20:18:19 +0000

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

сереализация

zss — Thu, 28 Jun 2007 09:57:53 +0000

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

сереализация

zss — Wed, 27 Jun 2007 16:53:49 +0000

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 — Mon, 18 Jun 2007 10:01:04 +0000

zss: ну где же ты, Hryak :)

сереализация

zss — Sun, 17 Jun 2007 13:23:45 +0000

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 — Thu, 14 Jun 2007 17:06:26 +0000

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

]

сереализация

Hryak — Thu, 14 Jun 2007 17:01:44 +0000

Hryak:

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

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

insert не трогай.

Цитата

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

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

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

сереализация

zss — Thu, 14 Jun 2007 16:50:36 +0000

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
что-то это не избавило от варнинга :(

сереализация

Hryak — Thu, 14 Jun 2007 16:46:52 +0000

Hryak:

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

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

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

Цитата

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

сереализация

zss — Thu, 14 Jun 2007 16:38:35 +0000

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 — Thu, 14 Jun 2007 16:36:01 +0000

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

сереализация

zss — Thu, 14 Jun 2007 16:34:00 +0000

zss:

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

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

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

Это ?

сереализация

Hryak — Thu, 14 Jun 2007 16:32:17 +0000

Hryak:

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

Что он хочет ?

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

сереализация

zss — Thu, 14 Jun 2007 16:19:26 +0000

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

]

Что он хочет ?

сереализация

Hryak — Wed, 21 Mar 2007 08:01:47 +0000

Hryak:

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

код вроде = unregistered_cast

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

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

сереализация

zss — Wed, 21 Mar 2007 04:17:40 +0000

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 — Tue, 20 Mar 2007 19:25:09 +0000

Hryak:

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

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

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

сереализация

zss — Tue, 20 Mar 2007 18:16:53 +0000

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;

}

/* -------------------------------------------------------------------------- */

сереализация

zss — Tue, 13 Mar 2007 16:24:12 +0000

zss: Hryak - ты лучший :)

сереализация

Hryak — Tue, 13 Mar 2007 16:22:45 +0000

Hryak:

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

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

#include <boost/serialization/utility.hpp>

сереализация

zss — Tue, 13 Mar 2007 16:18:42 +0000

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

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

сереализация

Hryak — Tue, 13 Mar 2007 16:13:58 +0000

Hryak:

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

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

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

Цитата

Some s ();

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

сереализация

zss — Tue, 13 Mar 2007 15:03:26 +0000

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 — Tue, 13 Mar 2007 14:52:34 +0000

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 — Tue, 13 Mar 2007 14:11:53 +0000

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 ==========

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

сереализация

Hryak — Mon, 05 Mar 2007 17:02:41 +0000

Hryak:

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

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

Да.

Цитата

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

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

сереализация

zss — Mon, 05 Mar 2007 16:20:42 +0000

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 — Mon, 05 Mar 2007 16:15:35 +0000

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

сереализация

zss — Mon, 05 Mar 2007 16:03:34 +0000

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

ПРЕДУПРЕЖДЕНИЕ

Опасно включать в карту указатели на какие-то объекты в памяти –

если объект сохраняется или передаётся по сети на другой компьютер,

то, скорее всего, после раскрутки буфера этот указатель будет указывать неизвестно куда,

а это никогда не приводило ни к чему хорошему.

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

сереализация

BlackEmperor — Mon, 05 Mar 2007 15:06:08 +0000

BlackEmperor: Классика жанра :)

сереализация

zss — Mon, 05 Mar 2007 15:03:04 +0000

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