Boost Serializtion 샘플2

Boost 1.55 버전 기준으로 작성했습니다.

#include <boost/archive/binary_iarchive.hpp>

#include <boost/archive/binary_oarchive.hpp>

#include <boost/serialization/serialization.hpp>

#include <boost/serialization/vector.hpp>

#include <boost/serialization/string.hpp>

#include <boost/serialization/map.hpp>

#include <boost/iostreams/stream.hpp>

#include <boost/iostreams/device/array.hpp>

#include <boost/iostreams/device/back_inserter.hpp>

#include <boost/pool/pool.hpp>

#include <boost/pool/object_pool.hpp>

#include <boost/pool/singleton_pool.hpp>

#include <boost/pool/pool_alloc.hpp>

#include <boost/timer.hpp>

#include <boost/progress.hpp>

#define SERIALIZATION_MACRO_BEGIN \

friend class boost::serialization::access; \

template< typename Archive > \

void serialize( Archive& ar, const unsigned int version ) \

{

#define SERIALIZATION_DERIVED(BASE_CLASS) \

ar & boost::serialization::base_object<BASE_CLASS>(*this);

#define SERIALIZE(DATA) \

ar & DATA;

#define SERIALIZATION_MACRO_END \

}

typedef std::vector< char, boost::fast_pool_allocator<char> > TEST_BUFFER_TYPE;

typedef boost::iostreams::back_insert_device< TEST_BUFFER_TYPE > TEST_STREAM_DEVICE;

typedef boost::iostreams::basic_array_source<char> TEST_ARRAY_DEVICE;

typedef boost::iostreams::stream< TEST_STREAM_DEVICE > TestOutStream;

typedef boost::iostreams::stream_buffer< TEST_ARRAY_DEVICE > TestInStream;

template <typename T> inline void SerializeObjectHelper(T const& obj, TEST_BUFFER_TYPE& buffer )

{

TestOutStream out_s_(buffer);

boost::archive::binary_oarchive out_ar_(out_s_);

out_ar_ << obj;

out_s_.flush();

}

template <typename T> inline void DeserializeObjectHelper(T& obj, char const* pRowData, size_t dataSize )

{

TestInStream in_s_(pRowData, dataSize);

boost::archive::binary_iarchive in_ar_(in_s_);

in_ar_ >> obj;

}

struct TestData

{

//std::vector< std::string > vDummyStrings;

int n1;

int n2;

int n3;

int n4;

float v1;

float v2;

float v3;

TestData()

{

n1 = 1;

n2 = 2;

n3 = 3;

v1 = 100.123123f;

v2 = 200.123f;

v3 = 65536.123123f;

}

SERIALIZATION_MACRO_BEGIN

//SERIALIZE(vDummyStrings)

SERIALIZE(n1)

SERIALIZE(n2)

SERIALIZE(n3)

SERIALIZE(n4)

SERIALIZE(v1)

SERIALIZE(v2)

SERIALIZE(v3)

SERIALIZATION_MACRO_END

};

struct TestDataDerived : public TestData

{

std::vector< float > vDummyfloat;

std::vector< int > vDummyint;

float v11;

float v22;

float v33;

TestDataDerived() {}

SERIALIZATION_MACRO_BEGIN

SERIALIZATION_DERIVED(TestData)

SERIALIZE(vDummyfloat)

SERIALIZE(vDummyint)

SERIALIZE(v11)

SERIALIZE(v22)

SERIALIZE(v33)

SERIALIZATION_MACRO_END

};

struct AddData

{

int a;

int b;

int c;

SERIALIZATION_MACRO_BEGIN

SERIALIZE(a)

SERIALIZE(b)

SERIALIZE(c)

SERIALIZATION_MACRO_END

};

void serialize2_main()

{

TestDataDerived data;

//vector< TestDataDerived > vTest;

for( int i = 0; i < 10; ++i )

{

data.vDummyfloat.push_back( static_cast< float >(i) );

data.vDummyint.push_back( static_cast< int >(i) );

}

AddData adddata;

TEST_BUFFER_TYPE buffer;

SerializeObjectHelper( data, buffer );

SerializeObjectHelper( adddata, buffer );

std::size_t size = sizeof(float);

TestDataDerived data2;

DeserializeObjectHelper( data2, &buffer[0], buffer.size() );

}