00001 #ifndef S11N_LITE_H_INCLUDED
00002 #define S11N_LITE_H_INCLUDED 1
00003
00004
00005
00006
00007 #define s11n_S11NLITE_INCLUDED 1
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057 namespace s11nlite { }
00058
00059 #include <memory>
00060
00061 #include <s11n.net/s11n/s11n.hpp>
00062 #include <s11n.net/s11n/io/data_node_io.hpp>
00063 #include <s11n.net/s11n/client_api.hpp>
00064
00065
00066 namespace s11nlite {
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078 typedef client_api<s11n::s11n_node> client_interface;
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092 typedef client_interface::node_type node_type;
00093
00094
00095 typedef client_interface::node_traits node_traits;
00096
00097
00098
00099
00100 typedef client_interface::serializer_interface serializer_interface;
00101
00102
00103
00104
00105
00106
00107
00108
00109 client_interface & instance();
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120 void instance( client_interface * newinstance );
00121
00122
00123
00124
00125
00126
00127
00128 serializer_interface * create_serializer();
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164 serializer_interface *
00165 create_serializer( const std::string & classname );
00166
00167
00168
00169
00170
00171
00172
00173 void serializer_class( const std::string & );
00174
00175
00176
00177
00178 std::string serializer_class();
00179
00180
00181
00182
00183
00184
00185 node_type *
00186 find_child( node_type & parent,
00187 const std::string subnodename );
00188
00189
00190
00191
00192 const node_type *
00193 find_child( const node_type & parent,
00194 const std::string subnodename );
00195
00196
00197
00198
00199 template <typename SerializableType>
00200 bool serialize( node_type & dest,
00201 const SerializableType & src )
00202 {
00203 return instance().template serialize<SerializableType>( dest, src );
00204 }
00205
00206
00207
00208
00209 template <typename SerializableType>
00210 bool serialize_subnode( node_type & dest,
00211 const std::string & subnodename,
00212 const SerializableType & src )
00213 {
00214 return instance().template serialize_subnode<SerializableType>( dest, subnodename, src );
00215 }
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226 bool save( const node_type & src, std::ostream & dest );
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236 bool save( const node_type & src, const std::string & filename );
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246 template <typename SerializableType>
00247 bool save( const SerializableType & src, std::ostream & dest )
00248 {
00249 return instance().template save<SerializableType>( src, dest );
00250 }
00251
00252
00253
00254
00255
00256
00257
00258
00259 template <typename SerializableType>
00260 bool save( const SerializableType & src, const std::string & dest )
00261 {
00262 return instance().template save<SerializableType>(src,dest);
00263 }
00264
00265
00266
00267
00268
00269
00270 node_type * load_node( const std::string & src );
00271
00272
00273
00274
00275
00276
00277
00278
00279 node_type * load_node( std::istream & src );
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316 template <typename SerializableType>
00317 SerializableType * deserialize( const node_type & src )
00318 {
00319 return instance().template deserialize<SerializableType>( src );
00320 }
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331 template <typename DeserializableT>
00332 bool deserialize( const node_type & src, DeserializableT & target )
00333 {
00334 return instance().template deserialize<DeserializableT>( src, target );
00335 }
00336
00337
00338
00339
00340
00341
00342
00343 template <typename DeserializableT>
00344 bool deserialize_subnode( const node_type & src,
00345 const std::string & subnodename,
00346 DeserializableT & target )
00347 {
00348 return instance().template deserialize_subnode<DeserializableT>( src, subnodename, target );
00349 }
00350
00351
00352
00353
00354
00355
00356 template <typename DeserializableT>
00357 DeserializableT * deserialize_subnode( const node_type & src,
00358 const std::string & subnodename )
00359 {
00360 return instance().template deserialize_subnode<DeserializableT>( src, subnodename );
00361 }
00362
00363
00364
00365
00366
00367
00368 template <typename SerializableType>
00369 SerializableType * load_serializable( std::istream & src )
00370 {
00371 return instance().template load_serializable<SerializableType>( src );
00372 }
00373
00374
00375
00376
00377
00378
00379 template <typename SerializableType>
00380 SerializableType * load_serializable( const std::string & src )
00381 {
00382 return instance().template load_serializable<SerializableType>( src );
00383 }
00384
00385
00386
00387
00388
00389
00390 template <typename SerializableType>
00391 SerializableType * s11n_clone( const SerializableType & tocp )
00392 {
00393 return instance().template clone<SerializableType>( tocp );
00394 }
00395
00396
00397
00398
00399 template <typename Type1, typename Type2>
00400 bool s11n_cast( const Type1 & t1, Type2 & t2 )
00401 {
00402 return instance().template cast<Type1,Type2>(t1,t2);
00403 }
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413 struct save_binary_f
00414 {
00415 typedef ::s11nlite::node_type node_type;
00416
00417
00418
00419
00420 inline bool operator()( node_type const & src, std::string const & dest ) const
00421 {
00422 return ::s11nlite::save( src, dest );
00423 }
00424
00425
00426
00427
00428 inline bool operator()( node_type const & src, std::ostream & dest ) const
00429 {
00430 return ::s11nlite::save( src, dest );
00431 }
00432
00433
00434
00435
00436 template <typename SerT>
00437 inline bool operator()( SerT const & src, std::string const & dest ) const
00438 {
00439 return ::s11nlite::save( src, dest );
00440 }
00441
00442
00443
00444
00445 template <typename SerT>
00446 inline bool operator()( SerT const & src, std::ostream & dest ) const
00447 {
00448 return ::s11nlite::save( src, dest );
00449 }
00450
00451
00452 };
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462 struct save_string_unary_f : ::s11n::serialize_unary_serializable_f_tag,
00463 ::s11n::serialize_unary_node_f_tag
00464 {
00465 typedef ::s11nlite::node_type node_type;
00466 const std::string destination;
00467
00468
00469
00470
00471
00472 explicit save_string_unary_f( std::string const & s ) : destination(s)
00473 {}
00474
00475
00476
00477
00478 bool operator()( node_type const & src ) const
00479 {
00480 return ::s11nlite::save( src, this->destination );
00481 }
00482
00483
00484
00485
00486 template <typename SerT>
00487 bool operator()( SerT const & src ) const
00488 {
00489 return ::s11nlite::save( src, this->destination );
00490 }
00491 };
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507 struct save_stream_unary_f : ::s11n::serialize_unary_serializable_f_tag,
00508 ::s11n::serialize_unary_node_f_tag
00509 {
00510 typedef ::s11nlite::node_type node_type;
00511 std::ostream & stream;
00512
00513
00514
00515
00516 explicit save_stream_unary_f( std::ostream & os ) : stream(os)
00517 {}
00518
00519
00520
00521
00522 bool operator()( node_type const & src ) const
00523 {
00524 return ::s11nlite::save( src, this->stream );
00525 }
00526
00527
00528
00529
00530 template <typename SerT>
00531 bool operator()( SerT const & src ) const
00532 {
00533 return ::s11nlite::save( src, this->stream );
00534 }
00535 };
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574 template <typename T,typename OutputT>
00575 struct save_nullary_base_f
00576 {
00577 T const & source;
00578 OutputT destination;
00579
00580
00581
00582
00583
00584
00585
00586
00587 save_nullary_base_f( T const & src, OutputT dest )
00588 : source(src), destination(dest)
00589 {}
00590
00591
00592
00593 inline bool operator()() const
00594 {
00595 return ::s11nlite::save( this->source, this->destination );
00596 }
00597 };
00598
00599
00600
00601
00602 struct save_node_string_nullary_f : save_nullary_base_f< ::s11nlite::node_type, const std::string >
00603 {
00604 typedef save_nullary_base_f< ::s11nlite::node_type, const std::string > parent_t;
00605 typedef ::s11nlite::node_type node_type;
00606
00607
00608
00609
00610 save_node_string_nullary_f( node_type const & src, std::string const & dest )
00611 : parent_t( src, dest )
00612 {}
00613
00614 };
00615
00616
00617
00618
00619
00620 struct save_node_stream_nullary_f : save_nullary_base_f< ::s11nlite::node_type, std::ostream & >
00621 {
00622 typedef save_nullary_base_f< ::s11nlite::node_type, std::ostream & > parent_t;
00623 typedef ::s11nlite::node_type node_type;
00624
00625
00626
00627
00628 save_node_stream_nullary_f( node_type const & src, std::ostream & dest )
00629 : parent_t( src, dest )
00630 {}
00631 };
00632
00633
00634
00635
00636 template <typename SerT>
00637 struct save_serializable_string_nullary_f : save_nullary_base_f< SerT, const std::string >
00638 {
00639 typedef save_nullary_base_f< SerT, const std::string > parent_t;
00640
00641
00642
00643
00644 save_serializable_string_nullary_f( SerT const & src, std::string const & dest )
00645 : parent_t( src, dest )
00646 {}
00647 };
00648
00649
00650
00651
00652 template <typename SerT>
00653 struct save_serializable_stream_nullary_f : save_nullary_base_f< SerT, std::ostream & >
00654 {
00655
00656
00657
00658
00659 typedef save_nullary_base_f< SerT, std::ostream & > parent_t;
00660 save_serializable_stream_nullary_f( SerT const & src, std::ostream & dest )
00661 : parent_t( src, dest )
00662 {}
00663 };
00664
00665
00666
00667
00668
00669 template <typename SerT>
00670 inline save_serializable_string_nullary_f<SerT>
00671 save_nullary_f( SerT const & src, std::string const & dest )
00672 {
00673 return save_serializable_string_nullary_f<SerT>( src, dest );
00674 }
00675
00676
00677
00678
00679 template <typename SerT>
00680 inline save_serializable_stream_nullary_f<SerT>
00681 save_nullary_f( SerT const & src, std::ostream & dest )
00682 {
00683 return save_serializable_stream_nullary_f<SerT>( src, dest );
00684 }
00685
00686
00687
00688
00689 inline save_node_string_nullary_f
00690 save_nullary_f( node_type const & src, std::string const & dest )
00691 {
00692 return save_node_string_nullary_f( src, dest );
00693 }
00694
00695
00696
00697 inline save_node_stream_nullary_f
00698 save_nullary_f( node_type const & src, std::ostream & dest )
00699 {
00700 return save_node_stream_nullary_f( src, dest );
00701 }
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711 struct load_node_stream_nullary_f
00712 {
00713 std::istream & stream;
00714 typedef ::s11nlite::node_type node_type;
00715
00716
00717
00718
00719 explicit load_node_stream_nullary_f( std::istream & s ) : stream(s)
00720 {}
00721
00722
00723
00724
00725
00726
00727 inline node_type * operator()() const
00728 {
00729 return ::s11nlite::load_node( this->stream );
00730 }
00731 };
00732
00733
00734
00735
00736 struct load_node_nullary_string_f
00737 {
00738 typedef ::s11nlite::node_type node_type;
00739 const std::string resource;
00740
00741
00742
00743
00744
00745 explicit load_node_nullary_string_f( std::string const & s ) : resource(s)
00746 {}
00747
00748
00749
00750
00751
00752
00753 inline node_type * operator()() const
00754 {
00755 return ::s11nlite::load_node( this->resource );
00756 }
00757 };
00758
00759
00760
00761
00762
00763 inline load_node_nullary_string_f
00764 load_node_nullary_f( std::string const & s )
00765 {
00766 return load_node_nullary_string_f(s);
00767 }
00768
00769
00770
00771
00772 inline load_node_stream_nullary_f
00773 load_node_nullary_f( std::istream & s )
00774 {
00775 return load_node_stream_nullary_f(s);
00776 }
00777
00778
00779
00780
00781
00782 struct load_node_unary_f
00783 {
00784
00785
00786
00787
00788 inline bool operator()( std::string const & src ) const
00789 {
00790 return ::s11nlite::load_node( src );
00791 }
00792
00793
00794
00795
00796 inline bool operator()( std::istream & src ) const
00797 {
00798 return ::s11nlite::load_node( src );
00799 }
00800 };
00801
00802
00803 }
00804
00805 #endif // S11N_LITE_H_INCLUDED