00001 #ifndef s11n_FUNCTOR_H_INCLUDED
00002 #define s11n_FUNCTOR_H_INCLUDED 1
00003
00004
00005
00006
00007
00008
00009 namespace s11n
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 struct object_deleter
00037 {
00038
00039
00040
00041 template <typename T>
00042 void operator()( const T * t ) const
00043 {
00044
00045
00046
00047
00048 delete( t );
00049 }
00050
00051
00052
00053
00054 template <typename T>
00055 void operator()( const T & t ) const
00056 {}
00057 };
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086 template <typename T>
00087 struct object_reference_wrapper
00088 {
00089 typedef T value_type;
00090 typedef T base_value_type;
00091 object_reference_wrapper() : m_ptr(0) {}
00092 object_reference_wrapper( value_type &obj ) : m_ptr(&obj) {};
00093
00094
00095
00096 base_value_type & operator()( value_type & t )
00097 {
00098 this->m_ptr = &t;
00099 return t;
00100 }
00101
00102
00103
00104
00105
00106
00107
00108
00109 base_value_type & operator()() const { return *(this->m_ptr); }
00110
00111
00112
00113
00114
00115 bool good() const
00116 {
00117 return 0 != this->m_ptr;
00118 }
00119
00120 private:
00121 value_type * m_ptr;
00122 };
00123
00124
00125
00126
00127
00128
00129 template <typename T>
00130 struct object_reference_wrapper<T *>
00131 {
00132 typedef T * value_type;
00133 typedef T base_value_type;
00134 object_reference_wrapper() : m_ptr(0) {}
00135 object_reference_wrapper( value_type & obj ) : m_ptr(obj) {};
00136
00137 base_value_type & operator()( value_type & t )
00138 {
00139 this->m_ptr = t;
00140 return *t;
00141 }
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151 base_value_type & operator()() const { return *(this->m_ptr); }
00152 private:
00153 base_value_type * m_ptr;
00154 };
00155
00156
00157
00158
00159
00160
00161
00162
00163 template <typename T>
00164 struct const_object_reference_wrapper
00165 {
00166 typedef T value_type;
00167 typedef T base_value_type;
00168 const_object_reference_wrapper() : m_ptr(0) {}
00169 const_object_reference_wrapper( const value_type &obj ) : m_ptr(&obj) {};
00170
00171
00172
00173 const base_value_type & operator()( const value_type & t )
00174 {
00175 this->m_ptr = t;
00176 return t;
00177 }
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188 const base_value_type & operator()() const { return *this->m_ptr; }
00189 private:
00190 const value_type * m_ptr;
00191 };
00192
00193
00194
00195
00196
00197
00198 template <typename T>
00199 struct const_object_reference_wrapper<T *>
00200 {
00201 typedef T * value_type;
00202 typedef T base_value_type;
00203 const_object_reference_wrapper() : m_ptr(0) {}
00204 const_object_reference_wrapper( const value_type & obj ) : m_ptr(obj) {};
00205
00206 const base_value_type & operator()( value_type & t )
00207 {
00208 this->m_ptr = t;
00209 return *t;
00210 }
00211
00212 const base_value_type & operator()() const { return *(this->m_ptr); }
00213 private:
00214 const base_value_type * m_ptr;
00215 };
00216
00217
00218
00219
00220
00221 template <typename T>
00222 object_reference_wrapper<T>
00223 reference_wrapper( T & t )
00224 {
00225 return object_reference_wrapper<T>( t );
00226 }
00227
00228
00229
00230
00231
00232 template <typename T>
00233 object_reference_wrapper<T>
00234 reference_wrapper()
00235 {
00236 return object_reference_wrapper<T>();
00237 }
00238
00239
00240
00241
00242
00243 template <typename T>
00244 const_object_reference_wrapper<T>
00245 const_reference_wrapper( const T & t )
00246 {
00247 return const_object_reference_wrapper<T>( t );
00248 }
00249
00250
00251
00252
00253
00254 template <typename T>
00255 const_object_reference_wrapper<T>
00256 const_reference_wrapper()
00257 {
00258 return const_object_reference_wrapper<T>();
00259 }
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274 struct pair_entry_deallocator
00275 {
00276
00277
00278
00279
00280 template <typename PairType>
00281 void operator()( PairType & p ) const
00282 {
00283 object_deleter od;
00284 od( p.first );
00285 od( p.second );
00286 }
00287 };
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308 template <typename ListType>
00309 class child_pointer_deep_copier
00310 {
00311 private:
00312 template <typename T> struct PtrStrip { typedef T type; };
00313 template <typename T> struct PtrStrip<T *> { typedef T type; };
00314 public:
00315 typedef ListType list_type;
00316 typedef typename ListType::value_type full_value_type;
00317 typedef typename PtrStrip<full_value_type>::type value_type;
00318
00319
00320
00321 child_pointer_deep_copier( list_type & target ) : m_childs(&target)
00322 {}
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334 bool operator()( const value_type * p )
00335 {
00336 if( ! this->m_childs || ! p ) return false;
00337 value_type * cp = 0;
00338 try
00339 {
00340 cp = new value_type( *p );
00341 if( ! cp ) return false;
00342 }
00343 catch(...) {
00344 delete( cp );
00345 return false;
00346 }
00347 this->m_childs->push_back( cp );
00348
00349 return true;
00350 }
00351 private:
00352 list_type * m_childs;
00353 };
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366 template <typename InputIt, typename OutputIt, typename Predicate>
00367 OutputIt copy_if (InputIt first,
00368 InputIt last,
00369 OutputIt result,
00370 Predicate pred)
00371 {
00372 while (first != last)
00373 {
00374 if (pred(*first)) *result++ = *first;
00375 ++first;
00376 }
00377 return result;
00378 }
00379
00380
00381
00382
00383 template <typename ComparedType>
00384 struct equal_to
00385 {
00386 typedef ComparedType compared_type;
00387 explicit equal_to( const compared_type & d ) : m_data(d)
00388 {}
00389
00390
00391
00392
00393
00394 void operator()( const compared_type & p )
00395 {
00396 return p == this->m_data;
00397 }
00398 private:
00399 compared_type m_data;
00400 };
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411 template <typename NameableT>
00412 struct same_name
00413 {
00414
00415
00416
00417
00418
00419 typedef NameableT nameable_type;
00420 explicit same_name( const std::string & n ) : m_name(n)
00421 {}
00422
00423 bool operator()( const nameable_type * x ) const
00424 {
00425 if( ! x ) return false;
00426 return x->name() == this->m_name;
00427 }
00428 private:
00429 std::string m_name;
00430 };
00431
00432
00433 }
00434
00435 #endif // s11n_FUNCTOR_H_INCLUDED