00001
00002
00003
00004
00005
00006
00007
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
00043 #ifndef RANGELIB_INCL_RANGELIB_HPP_BASIC_INDIRECT_RANGE_ADAPTOR
00044 #define RANGELIB_INCL_RANGELIB_HPP_BASIC_INDIRECT_RANGE_ADAPTOR
00045
00046 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00047 # define RANGELIB_VER_RANGELIB_HPP_BASIC_INDIRECT_RANGE_ADAPTOR_MAJOR 2
00048 # define RANGELIB_VER_RANGELIB_HPP_BASIC_INDIRECT_RANGE_ADAPTOR_MINOR 1
00049 # define RANGELIB_VER_RANGELIB_HPP_BASIC_INDIRECT_RANGE_ADAPTOR_REVISION 2
00050 # define RANGELIB_VER_RANGELIB_HPP_BASIC_INDIRECT_RANGE_ADAPTOR_EDIT 30
00051 #endif
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068 #ifndef RANGELIB_INCL_RANGELIB_HPP_RANGELIB
00069 # include <rangelib/rangelib.hpp>
00070 #endif
00071 #ifndef RANGELIB_INCL_RANGELIB_HPP_RANGE_CATEGORIES
00072 # include <rangelib/range_categories.hpp>
00073 #endif
00074
00075 #ifndef STLSOFT_INCL_ITERATOR
00076 # define STLSOFT_INCL_ITERATOR
00077 # include <iterator>
00078 #endif
00079 #ifndef STLSOFT_INCL_FUNCTIONAL
00080 # define STLSOFT_INCL_FUNCTIONAL
00081 # include <functional>
00082 #endif
00083
00084
00085
00086
00087
00088 #ifndef RANGELIB_NO_NAMESPACE
00089 # if defined(_STLSOFT_NO_NAMESPACE) || \
00090 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00091
00092 namespace rangelib
00093 {
00094 # else
00095
00096
00097 namespace stlsoft
00098 {
00099
00100 namespace rangelib_project
00101 {
00102
00103 # endif
00104 #endif
00105
00106
00107
00108
00109
00110 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00111 namespace
00112 {
00113 template <ss_typename_param_k T>
00114 struct accumulate_1_function
00115 {
00116 public:
00117 accumulate_1_function(T &total)
00118 : m_total(total)
00119 {}
00120
00121 public:
00122 template <ss_typename_param_k T2>
00123 ss_bool_t operator ()(T2 val)
00124 {
00125 m_total = m_total + val;
00126
00127 return true;
00128 }
00129
00130 private:
00131 T &m_total;
00132 };
00133
00134 template< ss_typename_param_k T
00135 , ss_typename_param_k P
00136 >
00137 struct accumulate_2_function
00138 {
00139 public:
00140 accumulate_2_function(T &total, P pr)
00141 : m_total(total)
00142 , m_pr(pr)
00143 {}
00144
00145 public:
00146 template <ss_typename_param_k T2>
00147 ss_bool_t operator ()(T2 val)
00148 {
00149 m_total = m_pr(m_total, val);
00150
00151 return true;
00152 }
00153
00154 private:
00155 T &m_total;
00156 P m_pr;
00157 };
00158
00159 template <ss_typename_param_k O>
00160 struct copy_function
00161 {
00162 public:
00163 copy_function(O o)
00164 : m_o(o)
00165 {}
00166
00167 public:
00168 template <ss_typename_param_k T2>
00169 ss_bool_t operator ()(T2 val)
00170 {
00171 *m_o++ = val;
00172
00173 return true;
00174 }
00175
00176 public:
00177 operator O()
00178 {
00179 return m_o;
00180 }
00181
00182 private:
00183 O m_o;
00184 };
00185
00186 template< ss_typename_param_k O
00187 , ss_typename_param_k P
00188 >
00189 struct copy_if_function
00190 {
00191 public:
00192 copy_if_function(O o, P pr)
00193 : m_o(o)
00194 , m_pr(pr)
00195 {}
00196
00197 public:
00198 template <ss_typename_param_k T2>
00199 ss_bool_t operator ()(T2 val)
00200 {
00201 if(m_pr(val))
00202 {
00203 *m_o++ = val;
00204 }
00205
00206 return true;
00207 }
00208
00209 public:
00210 operator O()
00211 {
00212 return m_o;
00213 }
00214
00215 private:
00216 O m_o;
00217 P m_pr;
00218 };
00219
00220 template <ss_typename_param_k T>
00221 struct count_function
00222 {
00223 public:
00224 count_function(size_t &n, T const& val)
00225 : m_n(n)
00226 , m_val(val)
00227 {}
00228
00229 public:
00230 template <ss_typename_param_k T2>
00231 ss_bool_t operator ()(T2 val) const
00232 {
00233 if(m_val == val)
00234 {
00235 ++m_n;
00236 }
00237
00238 return true;
00239 }
00240 private:
00241 size_t &m_n;
00242 T const& m_val;
00243 };
00244
00245 template <ss_typename_param_k P>
00246 struct count_if_function
00247 {
00248 public:
00249 count_if_function(size_t &n, P pr)
00250 : m_n(n)
00251 , m_pr(pr)
00252 {}
00253
00254 public:
00255 template <ss_typename_param_k T2>
00256 ss_bool_t operator ()(T2 val) const
00257 {
00258 if(m_pr(val))
00259 {
00260 ++m_n;
00261 }
00262
00263 return true;
00264 }
00265 private:
00266 size_t &m_n;
00267 P m_pr;
00268 };
00269
00270 struct distance_function
00271 {
00272 public:
00273 distance_function(ptrdiff_t &count)
00274 : m_count(count)
00275 {}
00276 public:
00277 template <ss_typename_param_k T>
00278 ss_bool_t operator ()(T ) const
00279 {
00280 return (++m_count, true);
00281 }
00282 private:
00283 ptrdiff_t &m_count;
00284
00285 private:
00286 distance_function& operator =(distance_function const&);
00287 };
00288
00289 template <ss_typename_param_k T>
00290 struct exists_function
00291 {
00292 public:
00293 exists_function(ss_bool_t &b, T const& val)
00294 : m_b(b)
00295 , m_val(val)
00296 {
00297 STLSOFT_ASSERT(!b);
00298 }
00299
00300 public:
00301 template <ss_typename_param_k T2>
00302 ss_bool_t operator ()(T2 val) const
00303 {
00304 if(m_val == val)
00305 {
00306 m_b = true;
00307
00308 return false;
00309 }
00310
00311 return true;
00312 }
00313 private:
00314 ss_bool_t &m_b;
00315 T const &m_val;
00316 };
00317
00318 template <ss_typename_param_k P>
00319 struct exists_if_1_function
00320 {
00321 public:
00322 exists_if_1_function(ss_bool_t &b, P pr)
00323 : m_b(b)
00324 , m_pr(pr)
00325 {
00326 STLSOFT_ASSERT(!b);
00327 }
00328
00329 public:
00330 template <ss_typename_param_k T2>
00331 ss_bool_t operator ()(T2 val) const
00332 {
00333 if(pf(val))
00334 {
00335 m_b = true;
00336
00337 return false;
00338 }
00339
00340 return true;
00341 }
00342 private:
00343 ss_bool_t &m_b;
00344 P m_pr;
00345 };
00346
00347 template< ss_typename_param_k P
00348 , ss_typename_param_k V
00349 >
00350 struct exists_if_2_function
00351 {
00352 public:
00353 exists_if_2_function(ss_bool_t &b, P pr, V &result)
00354 : m_b(b)
00355 , m_pr(pr)
00356 , m_result(result)
00357 {
00358 STLSOFT_ASSERT(!b);
00359 }
00360
00361 public:
00362 template <ss_typename_param_k T2>
00363 ss_bool_t operator ()(T2 val) const
00364 {
00365 if(pf(val))
00366 {
00367 m_b = true;
00368 m_result = val;
00369
00370 return false;
00371 }
00372
00373 return true;
00374 }
00375 private:
00376 ss_bool_t &m_b;
00377 P m_pr;
00378 V &m_result;
00379 };
00380
00381 template <ss_typename_param_k F>
00382 struct for_each_function
00383 {
00384 public:
00385 for_each_function(F f)
00386 : m_f(f)
00387 {}
00388 public:
00389 template <ss_typename_param_k T>
00390 ss_bool_t operator ()(T v) const
00391 {
00392 return (m_f(v), true);
00393 }
00394 private:
00395 F m_f;
00396 };
00397
00398 template< ss_typename_param_k V
00399 , ss_typename_param_k P
00400 >
00401 struct minmax_element_2_function
00402 {
00403 public:
00404 minmax_element_2_function(ss_bool_t &bRetrieved, P pr, V &result)
00405 : m_bRetrieved(bRetrieved)
00406 , m_pr(pr)
00407 , m_result(result)
00408 {}
00409 public:
00410 template <ss_typename_param_k T>
00411 ss_bool_t operator ()(T val) const
00412 {
00413 if(!m_bRetrieved)
00414 {
00415 m_result = val;
00416
00417 m_bRetrieved = true;
00418 }
00419 else
00420 {
00421 if(m_pr(m_result, val))
00422 {
00423 m_result = val;
00424 }
00425 }
00426
00427 return true;
00428 }
00429 private:
00430 ss_bool_t &m_bRetrieved;
00431 P m_pr;
00432 V &m_result;
00433 };
00434
00435 }
00436
00437 #endif
00438
00439
00440
00441
00442
00447 template <ss_typename_param_k R>
00448 class indirect_range_adaptor
00449 : public indirect_range_tag
00450 {
00451 public:
00452 typedef R range_type;
00453 typedef ss_typename_type_k R::value_type value_type;
00454
00455 public:
00459 indirect_range_adaptor(range_type r)
00460 : m_r(r)
00461 {}
00462
00464 template <ss_typename_param_k T>
00465 T accumulate(T val) const
00466 {
00467 T total = val;
00468
00469 m_r.for_each_cancelable(accumulate_1_function<T>(total));
00470
00471 return total;
00472 }
00473
00475 template< ss_typename_param_k T
00476 , ss_typename_param_k P
00477 >
00478 T accumulate(T val, P pr) const
00479 {
00480 T total = val;
00481
00482 m_r.for_each_cancelable(accumulate_2_function<T, P>(total, pr));
00483
00484 return total;
00485 }
00486
00488 template <ss_typename_param_k O>
00489 O copy(O o) const
00490 {
00491 copy_function<O> cf(o);
00492
00493 m_r.for_each_cancelable(cf);
00494
00495 return cf;
00496 }
00497
00499 template< ss_typename_param_k O
00500 , ss_typename_param_k P
00501 >
00502 O copy_if(O o, P pr) const
00503 {
00504 copy_if_function<O, P> cf(o, pr);
00505
00506 m_r.for_each_cancelable(cf);
00507
00508 return cf;
00509 }
00510
00512 template <ss_typename_param_k T>
00513 size_t count(T const& val) const
00514 {
00515 size_t n = 0;
00516
00517 m_r.for_each_cancelable(count_function<T>(n, val));
00518
00519 return n;
00520 }
00521
00523 template <ss_typename_param_k P>
00524 size_t count_if(P pr) const
00525 {
00526 size_t n = 0;
00527
00528 m_r.for_each_cancelable(count_if_function<P>(n, pr));
00529
00530 return n;
00531 }
00532
00534 ptrdiff_t distance() const
00535 {
00536 ptrdiff_t n = 0;
00537
00538 m_r.for_each_cancelable(distance_function(n));
00539
00540 return n;
00541 }
00542
00544 template <ss_typename_param_k F>
00545 F for_each(F f)
00546 {
00547 m_r.for_each_cancelable(for_each_function<F>(f));
00548
00549 return f;
00550 }
00551
00553 template <ss_typename_param_k T>
00554 ss_bool_t exists(T const& val) const
00555 {
00556 ss_bool_t bExists = false;
00557
00558 m_r.for_each_cancelable(exists_function<T>(bExists, val));
00559
00560 return bExists;
00561 }
00562
00565 template <ss_typename_param_k P>
00566 ss_bool_t exists_if(P pr) const
00567 {
00568 ss_bool_t bExists = false;
00569
00570 m_r.for_each_cancelable(exists_if_1_function<P>(bExists, pr));
00571
00572 return bExists;
00573 }
00574
00577 template< ss_typename_param_k P
00578 , ss_typename_param_k T>
00579 ss_bool_t exists_if(P pr, T &result) const
00580 {
00581 ss_bool_t bExists = false;
00582
00583 m_r.for_each_cancelable(exists_if_2_function<P, T>(bExists, pr, result));
00584
00585 return bExists;
00586 }
00587
00589 value_type max_element() const
00590 {
00591 return minmax_element(std::less<value_type>());
00592 }
00593
00596 template <ss_typename_param_k P>
00597 value_type max_element(P pr) const
00598 {
00599 return minmax_element(pr);
00600 }
00601
00603 value_type min_element() const
00604 {
00605 return minmax_element(std::greater<value_type>());
00606 }
00607
00610 template <ss_typename_param_k P>
00611 value_type min_element(P pr) const
00612 {
00613 return minmax_element(std::not2(pr));
00614 }
00615
00616 private:
00617 template <ss_typename_param_k P>
00618 value_type minmax_element(P pr) const
00619 {
00620 ss_bool_t bRetrieved;
00621 value_type result;
00622
00623 m_r.for_each_cancelable(minmax_element_2_function<value_type, P>(bRetrieved, pr, result));
00624
00625 STLSOFT_ASSERT(bRetrieved);
00626
00627 return result;
00628 }
00629
00630 private:
00631 range_type m_r;
00632 };
00633
00635
00636
00637 #ifdef STLSOFT_UNITTEST
00638 # include "./unittest/basic_indirect_range_adaptor_unittest_.h"
00639 #endif
00640
00641
00642
00643 #ifndef RANGELIB_NO_NAMESPACE
00644 # if defined(_STLSOFT_NO_NAMESPACE) || \
00645 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00646 }
00647 # else
00648 }
00649 }
00650 # endif
00651 #endif
00652
00653
00654
00655 #endif
00656
00657