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
00034 #ifndef _TR1_FUNCTIONAL
00035 #define _TR1_FUNCTIONAL 1
00036
00037 #pragma GCC system_header
00038
00039 #include "../functional"
00040 #include <typeinfo>
00041 #include <tr1/type_traits>
00042 #include <bits/cpp_type_traits.h>
00043 #include <string>
00044 #include <cstdlib>
00045 #include <cmath>
00046 #include <tr1/tuple>
00047
00048 namespace std
00049 {
00050 namespace tr1
00051 {
00052 template<typename _MemberPointer>
00053 class _Mem_fn;
00054
00062 template<typename _Tp>
00063 class _Has_result_type_helper : __sfinae_types
00064 {
00065 template<typename _Up>
00066 struct _Wrap_type
00067 { };
00068
00069 template<typename _Up>
00070 static __one __test(_Wrap_type<typename _Up::result_type>*);
00071
00072 template<typename _Up>
00073 static __two __test(...);
00074
00075 public:
00076 static const bool value = sizeof(__test<_Tp>(0)) == 1;
00077 };
00078
00079 template<typename _Tp>
00080 struct _Has_result_type
00081 : integral_constant<
00082 bool,
00083 _Has_result_type_helper<typename remove_cv<_Tp>::type>::value>
00084 { };
00085
00091 template<bool _Has_result_type, typename _Functor>
00092 struct _Maybe_get_result_type
00093 { };
00094
00095 template<typename _Functor>
00096 struct _Maybe_get_result_type<true, _Functor>
00097 {
00098 typedef typename _Functor::result_type result_type;
00099 };
00100
00107 template<typename _Functor>
00108 struct _Weak_result_type_impl
00109 : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor>
00110 {
00111 };
00112
00119 template<typename _Functor>
00120 struct _Weak_result_type
00121 : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
00122 {
00123 };
00124
00125 template<typename _Signature>
00126 class result_of;
00127
00136 template<bool _Has_result_type, typename _Signature>
00137 struct _Result_of_impl;
00138
00139
00140 template<typename _Res, typename _Class, typename _T1>
00141 struct _Result_of_impl<false, _Res _Class::*(_T1)>
00142 {
00143 typedef typename _Mem_fn<_Res _Class::*>
00144 ::template _Result_type<_T1>::type type;
00145 };
00146
00152 template<typename _Tp>
00153 struct _Derives_from_unary_function : __sfinae_types
00154 {
00155 private:
00156 template<typename _T1, typename _Res>
00157 static __one __test(const volatile unary_function<_T1, _Res>*);
00158
00159
00160
00161 static __two __test(...);
00162
00163 public:
00164 static const bool value = sizeof(__test((_Tp*)0)) == 1;
00165 };
00166
00172 template<typename _Tp>
00173 struct _Derives_from_binary_function : __sfinae_types
00174 {
00175 private:
00176 template<typename _T1, typename _T2, typename _Res>
00177 static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
00178
00179
00180
00181 static __two __test(...);
00182
00183 public:
00184 static const bool value = sizeof(__test((_Tp*)0)) == 1;
00185 };
00186
00192 template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
00193 struct _Function_to_function_pointer
00194 {
00195 typedef _Tp type;
00196 };
00197
00198 template<typename _Tp>
00199 struct _Function_to_function_pointer<_Tp, true>
00200 {
00201 typedef _Tp* type;
00202 };
00203
00211 template<bool _Unary, bool _Binary, typename _Tp>
00212 struct _Reference_wrapper_base_impl;
00213
00214
00215 template<typename _Tp>
00216 struct _Reference_wrapper_base_impl<false, false, _Tp>
00217 : _Weak_result_type<_Tp>
00218 { };
00219
00220
00221 template<typename _Tp>
00222 struct _Reference_wrapper_base_impl<true, false, _Tp>
00223 : unary_function<typename _Tp::argument_type,
00224 typename _Tp::result_type>
00225 { };
00226
00227
00228 template<typename _Tp>
00229 struct _Reference_wrapper_base_impl<false, true, _Tp>
00230 : binary_function<typename _Tp::first_argument_type,
00231 typename _Tp::second_argument_type,
00232 typename _Tp::result_type>
00233 { };
00234
00235
00236
00237 template<typename _Tp>
00238 struct _Reference_wrapper_base_impl<true, true, _Tp>
00239 : unary_function<typename _Tp::argument_type,
00240 typename _Tp::result_type>,
00241 binary_function<typename _Tp::first_argument_type,
00242 typename _Tp::second_argument_type,
00243 typename _Tp::result_type>
00244 {
00245 typedef typename _Tp::result_type result_type;
00246 };
00247
00256 template<typename _Tp>
00257 struct _Reference_wrapper_base
00258 : _Reference_wrapper_base_impl<
00259 _Derives_from_unary_function<_Tp>::value,
00260 _Derives_from_binary_function<_Tp>::value,
00261 _Tp>
00262 { };
00263
00264
00265 template<typename _Res, typename _T1>
00266 struct _Reference_wrapper_base<_Res(_T1)>
00267 : unary_function<_T1, _Res>
00268 { };
00269
00270
00271 template<typename _Res, typename _T1, typename _T2>
00272 struct _Reference_wrapper_base<_Res(_T1, _T2)>
00273 : binary_function<_T1, _T2, _Res>
00274 { };
00275
00276
00277 template<typename _Res, typename _T1>
00278 struct _Reference_wrapper_base<_Res(*)(_T1)>
00279 : unary_function<_T1, _Res>
00280 { };
00281
00282
00283 template<typename _Res, typename _T1, typename _T2>
00284 struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
00285 : binary_function<_T1, _T2, _Res>
00286 { };
00287
00288
00289 template<typename _Res, typename _T1>
00290 struct _Reference_wrapper_base<_Res (_T1::*)()>
00291 : unary_function<_T1*, _Res>
00292 { };
00293
00294
00295 template<typename _Res, typename _T1, typename _T2>
00296 struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
00297 : binary_function<_T1*, _T2, _Res>
00298 { };
00299
00300
00301 template<typename _Res, typename _T1>
00302 struct _Reference_wrapper_base<_Res (_T1::*)() const>
00303 : unary_function<const _T1*, _Res>
00304 { };
00305
00306
00307 template<typename _Res, typename _T1, typename _T2>
00308 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
00309 : binary_function<const _T1*, _T2, _Res>
00310 { };
00311
00312
00313 template<typename _Res, typename _T1>
00314 struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
00315 : unary_function<volatile _T1*, _Res>
00316 { };
00317
00318
00319 template<typename _Res, typename _T1, typename _T2>
00320 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
00321 : binary_function<volatile _T1*, _T2, _Res>
00322 { };
00323
00324
00325 template<typename _Res, typename _T1>
00326 struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
00327 : unary_function<const volatile _T1*, _Res>
00328 { };
00329
00330
00331 template<typename _Res, typename _T1, typename _T2>
00332 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
00333 : binary_function<const volatile _T1*, _T2, _Res>
00334 { };
00335
00336 template<typename _Tp>
00337 class reference_wrapper
00338 : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
00339 {
00340
00341
00342 typedef typename _Function_to_function_pointer<_Tp>::type
00343 _M_func_type;
00344
00345 _Tp* _M_data;
00346 public:
00347 typedef _Tp type;
00348 explicit reference_wrapper(_Tp& __indata): _M_data(&__indata)
00349 { }
00350
00351 reference_wrapper(const reference_wrapper<_Tp>& __inref):
00352 _M_data(__inref._M_data)
00353 { }
00354
00355 reference_wrapper&
00356 operator=(const reference_wrapper<_Tp>& __inref)
00357 {
00358 _M_data = __inref._M_data;
00359 return *this;
00360 }
00361
00362 operator _Tp&() const
00363 { return this->get(); }
00364
00365 _Tp&
00366 get() const
00367 { return *_M_data; }
00368
00369 #define _GLIBCXX_REPEAT_HEADER <tr1/ref_wrap_iterate.h>
00370 #include <tr1/repeat.h>
00371 #undef _GLIBCXX_REPEAT_HEADER
00372 };
00373
00374
00375
00376 template<typename _Tp>
00377 inline reference_wrapper<_Tp>
00378 ref(_Tp& __t)
00379 { return reference_wrapper<_Tp>(__t); }
00380
00381
00382 template<typename _Tp>
00383 inline reference_wrapper<const _Tp>
00384 cref(const _Tp& __t)
00385 { return reference_wrapper<const _Tp>(__t); }
00386
00387 template<typename _Tp>
00388 inline reference_wrapper<_Tp>
00389 ref(reference_wrapper<_Tp> __t)
00390 { return ref(__t.get()); }
00391
00392 template<typename _Tp>
00393 inline reference_wrapper<const _Tp>
00394 cref(reference_wrapper<_Tp> __t)
00395 { return cref(__t.get()); }
00396
00397 template<typename _Tp, bool>
00398 struct _Mem_fn_const_or_non
00399 {
00400 typedef const _Tp& type;
00401 };
00402
00403 template<typename _Tp>
00404 struct _Mem_fn_const_or_non<_Tp, false>
00405 {
00406 typedef _Tp& type;
00407 };
00408
00409 template<typename _Res, typename _Class>
00410 class _Mem_fn<_Res _Class::*>
00411 {
00412
00413
00414 template<typename _Tp>
00415 _Res&
00416 _M_call(_Tp& __object, _Class *) const
00417 { return __object.*__pm; }
00418
00419 template<typename _Tp, typename _Up>
00420 _Res&
00421 _M_call(_Tp& __object, _Up * const *) const
00422 { return (*__object).*__pm; }
00423
00424 template<typename _Tp, typename _Up>
00425 const _Res&
00426 _M_call(_Tp& __object, const _Up * const *) const
00427 { return (*__object).*__pm; }
00428
00429 template<typename _Tp>
00430 const _Res&
00431 _M_call(_Tp& __object, const _Class *) const
00432 { return __object.*__pm; }
00433
00434 template<typename _Tp>
00435 const _Res&
00436 _M_call(_Tp& __ptr, const volatile void*) const
00437 { return (*__ptr).*__pm; }
00438
00439 template<typename _Tp> static _Tp& __get_ref();
00440
00441 template<typename _Tp>
00442 static __sfinae_types::__one __check_const(_Tp&, _Class*);
00443 template<typename _Tp, typename _Up>
00444 static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
00445 template<typename _Tp, typename _Up>
00446 static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
00447 template<typename _Tp>
00448 static __sfinae_types::__two __check_const(_Tp&, const _Class*);
00449 template<typename _Tp>
00450 static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
00451
00452 public:
00453 template<typename _Tp>
00454 struct _Result_type
00455 : _Mem_fn_const_or_non<
00456 _Res,
00457 (sizeof(__sfinae_types::__two)
00458 == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
00459 { };
00460
00461 template<typename _Signature>
00462 struct result;
00463
00464 template<typename _CVMem, typename _Tp>
00465 struct result<_CVMem(_Tp)>
00466 : public _Result_type<_Tp> { };
00467
00468 template<typename _CVMem, typename _Tp>
00469 struct result<_CVMem(_Tp&)>
00470 : public _Result_type<_Tp> { };
00471
00472 explicit _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
00473
00474
00475 _Res& operator()(_Class& __object) const
00476 { return __object.*__pm; }
00477
00478 const _Res& operator()(const _Class& __object) const
00479 { return __object.*__pm; }
00480
00481
00482 _Res& operator()(_Class* __object) const
00483 { return __object->*__pm; }
00484
00485 const _Res&
00486 operator()(const _Class* __object) const
00487 { return __object->*__pm; }
00488
00489
00490 template<typename _Tp>
00491 typename _Result_type<_Tp>::type
00492 operator()(_Tp& __unknown) const
00493 { return _M_call(__unknown, &__unknown); }
00494
00495 private:
00496 _Res _Class::*__pm;
00497 };
00498
00503 template<typename _Tp, typename _Class>
00504 inline _Mem_fn<_Tp _Class::*>
00505 mem_fn(_Tp _Class::* __pm)
00506 {
00507 return _Mem_fn<_Tp _Class::*>(__pm);
00508 }
00509
00515 template<typename _Tp>
00516 struct is_bind_expression
00517 {
00518 static const bool value = false;
00519 };
00520
00525 template<typename _Tp>
00526 struct is_placeholder
00527 {
00528 static const int value = 0;
00529 };
00530
00536 template<int _Num> struct _Placeholder { };
00537
00544 template<int _Num>
00545 struct is_placeholder<_Placeholder<_Num> >
00546 {
00547 static const int value = _Num;
00548 };
00549
00563 template<typename _Arg,
00564 bool _IsBindExp = is_bind_expression<_Arg>::value,
00565 bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
00566 class _Mu;
00567
00574 template<typename _Tp>
00575 class _Mu<reference_wrapper<_Tp>, false, false>
00576 {
00577 public:
00578 typedef _Tp& result_type;
00579
00580
00581
00582
00583
00584 template<typename _CVRef, typename _Tuple>
00585 result_type
00586 operator()(_CVRef& __arg, const _Tuple&) const volatile
00587 { return __arg.get(); }
00588 };
00589
00597 template<typename _Arg>
00598 class _Mu<_Arg, true, false>
00599 {
00600 public:
00601 template<typename _Signature> class result;
00602
00603 #define _GLIBCXX_REPEAT_HEADER <tr1/mu_iterate.h>
00604 # include <tr1/repeat.h>
00605 #undef _GLIBCXX_REPEAT_HEADER
00606 };
00607
00615 template<typename _Arg>
00616 class _Mu<_Arg, false, true>
00617 {
00618 public:
00619 template<typename _Signature> class result;
00620
00621 template<typename _CVMu, typename _CVArg, typename _Tuple>
00622 class result<_CVMu(_CVArg, _Tuple)>
00623 {
00624
00625
00626
00627 typedef typename tuple_element<(is_placeholder<_Arg>::value - 1),
00628 _Tuple>::type __base_type;
00629
00630 public:
00631 typedef typename add_reference<__base_type>::type type;
00632 };
00633
00634 template<typename _Tuple>
00635 typename result<_Mu(_Arg, _Tuple)>::type
00636 operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
00637 {
00638 return ::std::tr1::get<(is_placeholder<_Arg>::value - 1)>(__tuple);
00639 }
00640 };
00641
00649 template<typename _Arg>
00650 class _Mu<_Arg, false, false>
00651 {
00652 public:
00653 template<typename _Signature> struct result;
00654
00655 template<typename _CVMu, typename _CVArg, typename _Tuple>
00656 struct result<_CVMu(_CVArg, _Tuple)>
00657 {
00658 typedef typename add_reference<_CVArg>::type type;
00659 };
00660
00661
00662 template<typename _CVArg, typename _Tuple>
00663 _CVArg& operator()(_CVArg& __arg, const _Tuple&) const volatile
00664 { return __arg; }
00665 };
00666
00674 template<typename _Tp>
00675 struct _Maybe_wrap_member_pointer
00676 {
00677 typedef _Tp type;
00678 static const _Tp& __do_wrap(const _Tp& __x) { return __x; }
00679 };
00680
00688 template<typename _Tp, typename _Class>
00689 struct _Maybe_wrap_member_pointer<_Tp _Class::*>
00690 {
00691 typedef _Mem_fn<_Tp _Class::*> type;
00692 static type __do_wrap(_Tp _Class::* __pm) { return type(__pm); }
00693 };
00694
00700 template<typename _Signature>
00701 struct _Bind;
00702
00708 template<typename _Result, typename _Signature>
00709 struct _Bind_result;
00710
00716 template<typename _Signature>
00717 struct is_bind_expression<_Bind<_Signature> >
00718 {
00719 static const bool value = true;
00720 };
00721
00727 template<typename _Result, typename _Signature>
00728 struct is_bind_expression<_Bind_result<_Result, _Signature> >
00729 {
00730 static const bool value = true;
00731 };
00732
00738 class bad_function_call : public std::exception { };
00739
00747 struct _M_clear_type;
00748
00756 template<typename _Tp>
00757 struct __is_location_invariant
00758 : integral_constant<bool,
00759 (is_pointer<_Tp>::value
00760 || is_member_pointer<_Tp>::value)>
00761 {
00762 };
00763
00764 class _Undefined_class;
00765
00766 union _Nocopy_types
00767 {
00768 void* _M_object;
00769 const void* _M_const_object;
00770 void (*_M_function_pointer)();
00771 void (_Undefined_class::*_M_member_pointer)();
00772 };
00773
00774 union _Any_data {
00775 void* _M_access() { return &_M_pod_data[0]; }
00776 const void* _M_access() const { return &_M_pod_data[0]; }
00777
00778 template<typename _Tp> _Tp& _M_access()
00779 { return *static_cast<_Tp*>(_M_access()); }
00780
00781 template<typename _Tp> const _Tp& _M_access() const
00782 { return *static_cast<const _Tp*>(_M_access()); }
00783
00784 _Nocopy_types _M_unused;
00785 char _M_pod_data[sizeof(_Nocopy_types)];
00786 };
00787
00788 enum _Manager_operation
00789 {
00790 __get_type_info,
00791 __get_functor_ptr,
00792 __clone_functor,
00793 __destroy_functor
00794 };
00795
00796
00797
00798 template<typename _Tp>
00799 struct _Simple_type_wrapper
00800 {
00801 _Simple_type_wrapper(_Tp __value) : __value(__value) { }
00802
00803 _Tp __value;
00804 };
00805
00806 template<typename _Tp>
00807 struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
00808 : __is_location_invariant<_Tp>
00809 {
00810 };
00811
00812
00813
00814 template<typename _Functor>
00815 inline _Functor& __callable_functor(_Functor& __f) { return __f; }
00816
00817 template<typename _Member, typename _Class>
00818 inline _Mem_fn<_Member _Class::*>
00819 __callable_functor(_Member _Class::* &__p)
00820 { return mem_fn(__p); }
00821
00822 template<typename _Member, typename _Class>
00823 inline _Mem_fn<_Member _Class::*>
00824 __callable_functor(_Member _Class::* const &__p)
00825 { return mem_fn(__p); }
00826
00827 template<typename _Signature, typename _Functor>
00828 class _Function_handler;
00829
00830 template<typename _Signature>
00831 class function;
00832
00833
00839 class _Function_base
00840 {
00841 public:
00842 static const std::size_t _M_max_size = sizeof(_Nocopy_types);
00843 static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
00844
00845 template<typename _Functor>
00846 class _Base_manager
00847 {
00848 protected:
00849 static const bool __stored_locally =
00850 (__is_location_invariant<_Functor>::value
00851 && sizeof(_Functor) <= _M_max_size
00852 && __alignof__(_Functor) <= _M_max_align
00853 && (_M_max_align % __alignof__(_Functor) == 0));
00854 typedef integral_constant<bool, __stored_locally> _Local_storage;
00855
00856
00857 static _Functor* _M_get_pointer(const _Any_data& __source)
00858 {
00859 const _Functor* __ptr =
00860 __stored_locally? &__source._M_access<_Functor>()
00861 : __source._M_access<_Functor*>();
00862 return const_cast<_Functor*>(__ptr);
00863 }
00864
00865
00866
00867 static void
00868 _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
00869 {
00870 new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
00871 }
00872
00873
00874
00875 static void
00876 _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
00877 {
00878 __dest._M_access<_Functor*>() =
00879 new _Functor(*__source._M_access<_Functor*>());
00880 }
00881
00882
00883
00884 static void
00885 _M_destroy(_Any_data& __victim, true_type)
00886 {
00887 __victim._M_access<_Functor>().~_Functor();
00888 }
00889
00890
00891 static void
00892 _M_destroy(_Any_data& __victim, false_type)
00893 {
00894 delete __victim._M_access<_Functor*>();
00895 }
00896
00897 public:
00898 static bool
00899 _M_manager(_Any_data& __dest, const _Any_data& __source,
00900 _Manager_operation __op)
00901 {
00902 switch (__op) {
00903 case __get_type_info:
00904 __dest._M_access<const type_info*>() = &typeid(_Functor);
00905 break;
00906
00907 case __get_functor_ptr:
00908 __dest._M_access<_Functor*>() = _M_get_pointer(__source);
00909 break;
00910
00911 case __clone_functor:
00912 _M_clone(__dest, __source, _Local_storage());
00913 break;
00914
00915 case __destroy_functor:
00916 _M_destroy(__dest, _Local_storage());
00917 break;
00918 }
00919 return false;
00920 }
00921
00922 static void
00923 _M_init_functor(_Any_data& __functor, const _Functor& __f)
00924 {
00925 _M_init_functor(__functor, __f, _Local_storage());
00926 }
00927
00928 template<typename _Signature>
00929 static bool
00930 _M_not_empty_function(const function<_Signature>& __f)
00931 {
00932 return __f;
00933 }
00934
00935 template<typename _Tp>
00936 static bool
00937 _M_not_empty_function(const _Tp*& __fp)
00938 {
00939 return __fp;
00940 }
00941
00942 template<typename _Class, typename _Tp>
00943 static bool
00944 _M_not_empty_function(_Tp _Class::* const& __mp)
00945 {
00946 return __mp;
00947 }
00948
00949 template<typename _Tp>
00950 static bool
00951 _M_not_empty_function(const _Tp&)
00952 {
00953 return true;
00954 }
00955
00956 private:
00957 static void
00958 _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type)
00959 {
00960 new (__functor._M_access()) _Functor(__f);
00961 }
00962
00963 static void
00964 _M_init_functor(_Any_data& __functor, const _Functor& __f, false_type)
00965 {
00966 __functor._M_access<_Functor*>() = new _Functor(__f);
00967 }
00968 };
00969
00970 template<typename _Functor>
00971 class _Ref_manager : public _Base_manager<_Functor*>
00972 {
00973 typedef _Function_base::_Base_manager<_Functor*> _Base;
00974
00975 public:
00976 static bool
00977 _M_manager(_Any_data& __dest, const _Any_data& __source,
00978 _Manager_operation __op)
00979 {
00980 switch (__op) {
00981 case __get_type_info:
00982 __dest._M_access<const type_info*>() = &typeid(_Functor);
00983 break;
00984
00985 case __get_functor_ptr:
00986 __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
00987 return is_const<_Functor>::value;
00988 break;
00989
00990 default:
00991 _Base::_M_manager(__dest, __source, __op);
00992 }
00993 return false;
00994 }
00995
00996 static void
00997 _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
00998 {
00999
01000 _Base::_M_init_functor(__functor, &__f.get());
01001 }
01002 };
01003
01004 _Function_base() : _M_manager(0) { }
01005
01006 ~_Function_base()
01007 {
01008 if (_M_manager)
01009 {
01010 _M_manager(_M_functor, _M_functor, __destroy_functor);
01011 }
01012 }
01013
01014
01015 bool _M_empty() const { return !_M_manager; }
01016
01017 typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
01018 _Manager_operation);
01019
01020 _Any_data _M_functor;
01021 _Manager_type _M_manager;
01022 };
01023
01024
01025
01033 template<typename _Signature>
01034 inline bool
01035 operator==(const function<_Signature>& __f, _M_clear_type*)
01036 {
01037 return !__f;
01038 }
01039
01043 template<typename _Signature>
01044 inline bool
01045 operator==(_M_clear_type*, const function<_Signature>& __f)
01046 {
01047 return !__f;
01048 }
01049
01057 template<typename _Signature>
01058 inline bool
01059 operator!=(const function<_Signature>& __f, _M_clear_type*)
01060 {
01061 return __f;
01062 }
01063
01067 template<typename _Signature>
01068 inline bool
01069 operator!=(_M_clear_type*, const function<_Signature>& __f)
01070 {
01071 return __f;
01072 }
01073
01074
01075
01081 template<typename _Signature>
01082 inline void
01083 swap(function<_Signature>& __x, function<_Signature>& __y)
01084 {
01085 __x.swap(__y);
01086 }
01087
01088 #define _GLIBCXX_JOIN(X,Y) _GLIBCXX_JOIN2( X , Y )
01089 #define _GLIBCXX_JOIN2(X,Y) _GLIBCXX_JOIN3(X,Y)
01090 #define _GLIBCXX_JOIN3(X,Y) X##Y
01091 #define _GLIBCXX_REPEAT_HEADER <tr1/functional_iterate.h>
01092 #include <tr1/repeat.h>
01093 #undef _GLIBCXX_REPEAT_HEADER
01094 #undef _GLIBCXX_JOIN3
01095 #undef _GLIBCXX_JOIN2
01096 #undef _GLIBCXX_JOIN
01097
01098
01099
01100 template<typename T>
01101 struct hash;
01102
01103 #define tr1_hashtable_define_trivial_hash(T) \
01104 template<> \
01105 struct hash<T> \
01106 : public std::unary_function<T, std::size_t> \
01107 { \
01108 std::size_t \
01109 operator()(T val) const \
01110 { return static_cast<std::size_t>(val); } \
01111 }
01112
01113 tr1_hashtable_define_trivial_hash(bool);
01114 tr1_hashtable_define_trivial_hash(char);
01115 tr1_hashtable_define_trivial_hash(signed char);
01116 tr1_hashtable_define_trivial_hash(unsigned char);
01117 tr1_hashtable_define_trivial_hash(wchar_t);
01118 tr1_hashtable_define_trivial_hash(short);
01119 tr1_hashtable_define_trivial_hash(int);
01120 tr1_hashtable_define_trivial_hash(long);
01121 tr1_hashtable_define_trivial_hash(unsigned short);
01122 tr1_hashtable_define_trivial_hash(unsigned int);
01123 tr1_hashtable_define_trivial_hash(unsigned long);
01124
01125 #undef tr1_hashtable_define_trivial_hash
01126
01127 template<typename T>
01128 struct hash<T*>
01129 : public std::unary_function<T*, std::size_t>
01130 {
01131 std::size_t
01132 operator()(T* p) const
01133 { return reinterpret_cast<std::size_t>(p); }
01134 };
01135
01136
01137
01138
01139
01140 template<std::size_t = sizeof(std::size_t)>
01141 struct Fnv_hash
01142 {
01143 static std::size_t
01144 hash(const char* first, std::size_t length)
01145 {
01146 std::size_t result = 0;
01147 for (; length > 0; --length)
01148 result = (result * 131) + *first++;
01149 return result;
01150 }
01151 };
01152
01153 template<>
01154 struct Fnv_hash<4>
01155 {
01156 static std::size_t
01157 hash(const char* first, std::size_t length)
01158 {
01159 std::size_t result = static_cast<std::size_t>(2166136261UL);
01160 for (; length > 0; --length)
01161 {
01162 result ^= (std::size_t)*first++;
01163 result *= 16777619UL;
01164 }
01165 return result;
01166 }
01167 };
01168
01169 template<>
01170 struct Fnv_hash<8>
01171 {
01172 static std::size_t
01173 hash(const char* first, std::size_t length)
01174 {
01175 std::size_t result = static_cast<std::size_t>(14695981039346656037ULL);
01176 for (; length > 0; --length)
01177 {
01178 result ^= (std::size_t)*first++;
01179 result *= 1099511628211ULL;
01180 }
01181 return result;
01182 }
01183 };
01184
01185
01186
01187
01188 template<>
01189 struct hash<std::string>
01190 : public std::unary_function<std::string, std::size_t>
01191 {
01192 std::size_t
01193 operator()(const std::string& s) const
01194 { return Fnv_hash<>::hash(s.data(), s.length()); }
01195 };
01196
01197 #ifdef _GLIBCXX_USE_WCHAR_T
01198 template<>
01199 struct hash<std::wstring>
01200 : public std::unary_function<std::wstring, std::size_t>
01201 {
01202 std::size_t
01203 operator()(const std::wstring& s) const
01204 {
01205 return Fnv_hash<>::hash(reinterpret_cast<const char*>(s.data()),
01206 s.length() * sizeof(wchar_t));
01207 }
01208 };
01209 #endif
01210
01211 template<>
01212 struct hash<float>
01213 : public std::unary_function<float, std::size_t>
01214 {
01215 std::size_t
01216 operator()(float fval) const
01217 {
01218 std::size_t result = 0;
01219
01220
01221 if (fval != 0.0f)
01222 result = Fnv_hash<>::hash(reinterpret_cast<const char*>(&fval),
01223 sizeof(fval));
01224 return result;
01225 }
01226 };
01227
01228 template<>
01229 struct hash<double>
01230 : public std::unary_function<double, std::size_t>
01231 {
01232 std::size_t
01233 operator()(double dval) const
01234 {
01235 std::size_t result = 0;
01236
01237
01238 if (dval != 0.0)
01239 result = Fnv_hash<>::hash(reinterpret_cast<const char*>(&dval),
01240 sizeof(dval));
01241 return result;
01242 }
01243 };
01244
01245
01246
01247 template<>
01248 struct hash<long double>
01249 : public std::unary_function<long double, std::size_t>
01250 {
01251 std::size_t
01252 operator()(long double ldval) const
01253 {
01254 std::size_t result = 0;
01255
01256 int exponent;
01257 ldval = std::frexp(ldval, &exponent);
01258 ldval = ldval < 0.0l ? -(ldval + 0.5l) : ldval;
01259
01260 const long double mult = std::numeric_limits<std::size_t>::max() + 1.0l;
01261 ldval *= mult;
01262
01263
01264
01265 const std::size_t hibits = (std::size_t)ldval;
01266 ldval = (ldval - (long double)hibits) * mult;
01267
01268 const std::size_t coeff =
01269 (std::numeric_limits<std::size_t>::max()
01270 / std::numeric_limits<long double>::max_exponent);
01271
01272 result = hibits + (std::size_t)ldval + coeff * exponent;
01273
01274 return result;
01275 }
01276 };
01277 }
01278 }
01279
01280 #endif