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