Changeset 44720


Ignore:
Timestamp:
Apr 22, 2008, 4:15:55 PM (10 years ago)
Author:
matus.chochlik
Message:

finished the example examples/serialization/cube.cpp showing cooperation with the Boost.Serialization library.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sandbox/mirror/libs/examples/serialization/cube.cpp

    r44700 r44720  
    22 * \file examples/serialization/cube.cpp
    33 * Example of registering namespaces, types and classes
    4  * and cooperation with the Boost.Serialization library
     4 * and cooperation with the Boost.Serialization library.
    55 *
    66 * NOTE: if You are not familiar with namespace and type
     
    2222
    2323#include <fstream>
    24 #include <boost/archive/xml_iarchive.hpp>
    25 #include <boost/archive/xml_oarchive.hpp>
     24#include <boost/archive/text_iarchive.hpp>
     25#include <boost/archive/text_oarchive.hpp>
    2626
    2727#include <boost/char_type_switch/iostream.hpp>
     
    6666                void set_z(float_type _z){z = _z;}
    6767                void set_w(float_type _w){w = _w;}
     68                //
     69                friend bool operator == (const CoordsTempl& a, const CoordsTempl& b)
     70                {
     71                        return
     72                                a.x == b.x &&
     73                                a.y == b.y &&
     74                                a.z == b.z &&
     75                                a.w == b.w;
     76                }
    6877        protected:
    6978                float_type x, y, z, w;
     
    8493                float_type length_squared(void){return x*x + y*y + z*z;}
    8594                float_type length(void){return sqrt(length_squared());}
     95                //
     96                friend bool operator == (const Vector& a, const Vector& b)
     97                {
     98                        return static_cast<const Coords&>(a) == static_cast<const Coords&>(b);
     99                }
    86100        private:
    87101        };
     
    103117                        , rtf( _width/2.0f,  _height/2.0f,  _depth/2.0f)
    104118                { }
    105         private:
     119                // the attribs are public which is actually not a good idea
     120                // but this is just an example
     121                //
    106122                // left-bottom-back
    107123                Vector lbb;
     
    120136                // right-top-front
    121137                Vector rtf;
     138                //
     139                friend bool operator == (const Cube& a, const Cube& b)
     140                {
     141                        return
     142                                a.lbb == b.lbb &&
     143                                a.lbf == b.lbf &&
     144                                a.ltb == b.ltb &&
     145                                a.ltf == b.ltf &&
     146                                a.rbb == b.rbb &&
     147                                a.rbf == b.rbf &&
     148                                a.rtb == b.rtb &&
     149                                a.rtf == b.rtf;
     150                }
    122151        };
    123152
     
    137166BOOST_MIRROR_REG_META_TYPE(_Graphics, ::Graphics, Coords)
    138167BOOST_MIRROR_REG_META_TYPE(_Graphics, ::Graphics, Vector)
     168BOOST_MIRROR_REG_META_TYPE(_Graphics, ::Graphics, Cube)
    139169
    140170
     
    178208BOOST_MIRROR_REG_CLASS_ATTRIBS_END
    179209
     210// register the attributes of Cube
     211BOOST_MIRROR_REG_CLASS_ATTRIBS_BEGIN(::Graphics::Cube) 
     212        BOOST_MIRROR_REG_CLASS_ATTRIB(
     213                0, ::Graphics::Vector,
     214                lbb
     215        )
     216        BOOST_MIRROR_REG_CLASS_ATTRIB(
     217                1, ::Graphics::Vector,
     218                lbf
     219        )
     220        BOOST_MIRROR_REG_CLASS_ATTRIB(
     221                2, ::Graphics::Vector,
     222                ltb
     223        )
     224        BOOST_MIRROR_REG_CLASS_ATTRIB(
     225                3, ::Graphics::Vector,
     226                ltf
     227        )
     228        BOOST_MIRROR_REG_CLASS_ATTRIB(
     229                4, ::Graphics::Vector,
     230                rbb
     231        )
     232        BOOST_MIRROR_REG_CLASS_ATTRIB(
     233                5, ::Graphics::Vector,
     234                rbf
     235        )
     236        BOOST_MIRROR_REG_CLASS_ATTRIB(
     237                6, ::Graphics::Vector,
     238                rtb
     239        )
     240        BOOST_MIRROR_REG_CLASS_ATTRIB(
     241                7, ::Graphics::Vector,
     242                rtf
     243        )
     244BOOST_MIRROR_REG_CLASS_ATTRIBS_END
     245
     246
    180247/** Support for serialization
    181248 */
     
    189256
    190257template <class Class>
     258to_be_loaded<Class> make_loadable(Class& _inst)
     259{
     260        return to_be_loaded<Class>(_inst);
     261}
     262
     263float& make_loadable(float& _inst)
     264{
     265        return _inst;
     266}
     267
     268template <class Class>
    191269struct to_be_saved
    192270{
     
    195273};
    196274
     275template <class Class>
     276to_be_saved<Class> make_saveable(const Class& _inst)
     277{
     278        return to_be_saved<Class>(_inst);
     279}
     280
     281const float& make_saveable(const float& _inst)
     282{
     283        return _inst;
     284}
     285
     286
     287template <class meta_class, class position>
     288struct single_attrib_loader
     289{
     290        template <class Archive, class Class>
     291        single_attrib_loader(Archive & ar, Class& c)
     292        {
     293                // first load the previous
     294                single_attrib_loader<meta_class, mpl::int_<position::value - 1> >(ar, c);
     295                // query the value of the current member
     296                mpl::at<meta_class::all_attributes::type_list, position>::type value;
     297                // load it
     298                ar >> make_loadable(value);
     299                // and set it
     300                meta_class::all_attributes::set(c, position(), value);
     301        }
     302};
     303
     304template <class meta_class>
     305struct single_attrib_loader<meta_class, mpl::int_<0> >
     306{
     307        template <class Archive, class Class>
     308        single_attrib_loader(Archive & ar, Class& c)
     309        {
     310                typedef mpl::int_<0> position;
     311                // we are on the first so just load it
     312                mpl::at<meta_class::all_attributes::type_list, position>::type value;
     313                ar >> make_loadable(value);
     314                meta_class::all_attributes::set(c, position(), value);
     315        }
     316};
     317
     318
     319
     320
    197321template<class Archive, class Class>
    198 void load(Archive & ar, Class & c, const unsigned int version)
     322void load(Archive & ar, Class & c)
    199323{
    200324        typedef BOOST_MIRROR_REFLECT_CLASS(Class) meta_Class;
    201 }
     325        typedef mpl::int_<meta_Class::all_attributes::size::value-1> last;
     326        single_attrib_loader<meta_Class, last>(ar, c);
     327}
     328
     329template <class meta_class, class position>
     330struct single_attrib_saver
     331{
     332        template <class Archive, class Class>
     333        single_attrib_saver(Archive & ar, const Class& c)
     334        {
     335                // first save the previous
     336                single_attrib_saver<meta_class, mpl::int_<position::value - 1> >(ar, c);
     337                // query the value of the current member
     338                mpl::at<meta_class::all_attributes::type_list, position>::type value;
     339                // and save it
     340                ar << make_saveable(meta_class::all_attributes::query(c, position(), value));
     341        }
     342};
     343
     344template <class meta_class>
     345struct single_attrib_saver<meta_class, mpl::int_<0> >
     346{
     347        template <class Archive, class Class>
     348        single_attrib_saver(Archive & ar, const Class& c)
     349        {
     350                typedef mpl::int_<0> position;
     351                // we are on the first so just save it
     352                // query the value of the current member
     353                mpl::at<meta_class::all_attributes::type_list, position>::type value;
     354                ar << make_saveable(meta_class::all_attributes::query(c, position(), value));
     355        }
     356};
    202357
    203358template<class Archive, class Class>
    204 void save(Archive & ar, const Class & c, const unsigned int version)
     359void save(Archive & ar, const Class & c)
    205360{
    206361        typedef BOOST_MIRROR_REFLECT_CLASS(Class) meta_Class;
     362        typedef mpl::int_<meta_Class::all_attributes::size::value-1> last;
     363        single_attrib_saver<meta_Class, last>(ar, c);
    207364}
    208365
     
    210367} // namespace mirror
    211368
    212 namespace serialization {
     369namespace archive {
    213370
    214371template<class Archive, class Class>
    215 void serialize(Archive & ar, mirror::to_be_saved<Class> dst, const unsigned int version)
    216 {
    217         mirror::save(ar, dst.inst, version);
     372void save(Archive & ar, mirror::to_be_saved<Class>& dst)
     373{
     374        mirror::save(ar, dst.inst);
    218375}
    219376
    220377template<class Archive, class Class>
    221 void serialize(Archive & ar, mirror::to_be_loaded<Class> src, const unsigned int version)
    222 {
    223         mirror::load(ar, src.inst, version);
    224 }
    225 
    226 
    227 } // namespace serialization
     378void load(Archive & ar, mirror::to_be_loaded<Class>& src)
     379{
     380        mirror::load(ar, src.inst);
     381}
     382
     383
     384} // namespace archive
     385
    228386} // namespace boost
    229387
     
    238396        using ::Graphics::Cube;
    239397        //
     398        // create two different cubes
    240399        Cube c1(2.0f, 2.0f, 2.0f), c2;
    241400        //
    242         boost::archive::xml_oarchive oa(cout);
    243         //
    244         oa << BOOST_SERIALIZATION_NVP(to_be_saved<Cube>(c1));
    245         //
     401        // save the first one into a text file
     402        {
     403                std::fstream out("temp.txt", ios_base::out);
     404                boost::archive::text_oarchive oa(out);
     405                //
     406                oa << make_saveable(c1);
     407        }
     408        //
     409        // load the second from the same file
     410        {
     411                std::fstream in("temp.txt", ios_base::in);
     412                boost::archive::text_iarchive ia(in);
     413                //
     414                ia >> make_loadable(c2);
     415        }
     416        // compare them
     417        assert(c1 == c2);
    246418        //
    247419        bcout << "Finished" << endl;
Note: See TracChangeset for help on using the changeset viewer.