Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / function / function_base.hpp
1 // Boost.Function library
2
3 //  Copyright Douglas Gregor 2001-2004. Use, modification and
4 //  distribution is subject to the Boost Software License, Version
5 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
6 //  http://www.boost.org/LICENSE_1_0.txt)
7
8 // For more information, see http://www.boost.org
9
10 #ifndef BOOST_FUNCTION_BASE_HEADER
11 #define BOOST_FUNCTION_BASE_HEADER
12
13 #include <stdexcept>
14 #include <string>
15 #include <memory>
16 #include <new>
17 #include <typeinfo>
18 #include <boost/config.hpp>
19 #include <boost/assert.hpp>
20 #include <boost/type_traits/is_integral.hpp>
21 #include <boost/type_traits/composite_traits.hpp>
22 #include <boost/type_traits/is_stateless.hpp>
23 #include <boost/ref.hpp>
24 #include <boost/pending/ct_if.hpp>
25 #include <boost/detail/workaround.hpp>
26 #ifndef BOOST_NO_SFINAE
27 #  include "boost/utility/enable_if.hpp"
28 #else
29 #  include "boost/mpl/bool.hpp"
30 #endif
31 #include <boost/function_equal.hpp>
32
33 // Borrowed from Boost.Python library: determines the cases where we
34 // need to use std::type_info::name to compare instead of operator==.
35 # if (defined(__GNUC__) && __GNUC__ >= 3) \
36  || defined(_AIX) \
37  || (   defined(__sgi) && defined(__host_mips))
38 #  include <cstring>
39 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
40      (std::strcmp((X).name(),(Y).name()) == 0)
41 # else
42 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
43 #endif
44
45 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
46 #  define BOOST_FUNCTION_TARGET_FIX(x) x
47 #else
48 #  define BOOST_FUNCTION_TARGET_FIX(x)
49 #endif // not MSVC
50
51 #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
52 // Work around a compiler bug.
53 // boost::python::objects::function has to be seen by the compiler before the
54 // boost::function class template.
55 namespace boost { namespace python { namespace objects {
56   class function;
57 }}}
58 #endif
59
60 #if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
61  || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
62  || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
63 #  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
64 #endif
65
66 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
67 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
68       typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
69                             (::boost::is_integral<Functor>::value)>::value), \
70                            Type>::type
71 #else
72 // BCC doesn't recognize this depends on a template argument and complains
73 // about the use of 'typename'
74 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
75       ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
76                    (::boost::is_integral<Functor>::value)>::value), \
77                        Type>::type
78 #endif
79
80 #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
81 namespace boost {
82
83 #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
84 // The library shipping with MIPSpro 7.3.1.3m has a broken allocator<void>
85 class function_base;
86
87 template<typename Signature,
88          typename Allocator = std::allocator<function_base> >
89 class function;
90 #else
91 template<typename Signature, typename Allocator = std::allocator<void> >
92 class function;
93 #endif
94
95 template<typename Signature, typename Allocator>
96 inline void swap(function<Signature, Allocator>& f1,
97                  function<Signature, Allocator>& f2)
98 {
99   f1.swap(f2);
100 }
101
102 } // end namespace boost
103 #endif // have partial specialization
104
105 namespace boost {
106   namespace detail {
107     namespace function {
108       /**
109        * A union of a function pointer and a void pointer. This is necessary
110        * because 5.2.10/6 allows reinterpret_cast<> to safely cast between
111        * function pointer types and 5.2.9/10 allows static_cast<> to safely
112        * cast between a void pointer and an object pointer. But it is not legal
113        * to cast between a function pointer and a void* (in either direction),
114        * so function requires a union of the two. */
115       union any_pointer
116       {
117         void* obj_ptr;
118         const void* const_obj_ptr;
119         void (*func_ptr)();
120         char data[1];
121       };
122
123       inline any_pointer make_any_pointer(void* o)
124       {
125         any_pointer p;
126         p.obj_ptr = o;
127         return p;
128       }
129
130       inline any_pointer make_any_pointer(const void* o)
131       {
132         any_pointer p;
133         p.const_obj_ptr = o;
134         return p;
135       }
136
137       inline any_pointer make_any_pointer(void (*f)())
138       {
139         any_pointer p;
140         p.func_ptr = f;
141         return p;
142       }
143
144       /**
145        * The unusable class is a placeholder for unused function arguments
146        * It is also completely unusable except that it constructable from
147        * anything. This helps compilers without partial specialization to
148        * handle Boost.Function objects returning void.
149        */
150       struct unusable
151       {
152         unusable() {}
153         template<typename T> unusable(const T&) {}
154       };
155
156       /* Determine the return type. This supports compilers that do not support
157        * void returns or partial specialization by silently changing the return
158        * type to "unusable".
159        */
160       template<typename T> struct function_return_type { typedef T type; };
161
162       template<>
163       struct function_return_type<void>
164       {
165         typedef unusable type;
166       };
167
168       // The operation type to perform on the given functor/function pointer
169       enum functor_manager_operation_type {
170         clone_functor_tag,
171         destroy_functor_tag,
172         check_functor_type_tag
173       };
174
175       // Tags used to decide between different types of functions
176       struct function_ptr_tag {};
177       struct function_obj_tag {};
178       struct member_ptr_tag {};
179       struct function_obj_ref_tag {};
180       struct stateless_function_obj_tag {};
181
182       template<typename F>
183       class get_function_tag
184       {
185         typedef typename ct_if<(is_pointer<F>::value),
186                             function_ptr_tag,
187                             function_obj_tag>::type ptr_or_obj_tag;
188
189         typedef typename ct_if<(is_member_pointer<F>::value),
190                             member_ptr_tag,
191                             ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
192
193         typedef typename ct_if<(is_reference_wrapper<F>::value),
194                              function_obj_ref_tag,
195                              ptr_or_obj_or_mem_tag>::type or_ref_tag;
196
197       public:
198         typedef typename ct_if<(is_stateless<F>::value),
199                             stateless_function_obj_tag,
200                             or_ref_tag>::type type;
201       };
202
203       // The trivial manager does nothing but return the same pointer (if we
204       // are cloning) or return the null pointer (if we are deleting).
205       template<typename F>
206       struct trivial_manager
207       {
208         static inline any_pointer
209         get(any_pointer f, functor_manager_operation_type op)
210         {
211           switch (op) {
212           case clone_functor_tag: return f;
213
214           case destroy_functor_tag:
215             return make_any_pointer(reinterpret_cast<void*>(0));
216
217           case check_functor_type_tag:
218             {
219               std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
220               return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
221                 f
222                 : make_any_pointer(reinterpret_cast<void*>(0));
223             }
224           }
225
226           // Clears up a warning with GCC 3.2.3
227           return make_any_pointer(reinterpret_cast<void*>(0));
228         }
229       };
230
231       /**
232        * The functor_manager class contains a static function "manage" which
233        * can clone or destroy the given function/function object pointer.
234        */
235       template<typename Functor, typename Allocator>
236       struct functor_manager
237       {
238       private:
239         typedef Functor functor_type;
240
241         // For function pointers, the manager is trivial
242         static inline any_pointer
243         manager(any_pointer function_ptr,
244                 functor_manager_operation_type op,
245                 function_ptr_tag)
246         {
247           if (op == clone_functor_tag)
248             return function_ptr;
249           else
250             return make_any_pointer(static_cast<void (*)()>(0));
251         }
252
253         // For function object pointers, we clone the pointer to each
254         // function has its own version.
255         static inline any_pointer
256         manager(any_pointer function_obj_ptr,
257                 functor_manager_operation_type op,
258                 function_obj_tag)
259         {
260 #ifndef BOOST_NO_STD_ALLOCATOR
261         typedef typename Allocator::template rebind<functor_type>::other
262           allocator_type;
263         typedef typename allocator_type::pointer pointer_type;
264 #else
265         typedef functor_type* pointer_type;
266 #endif // BOOST_NO_STD_ALLOCATOR
267
268 #  ifndef BOOST_NO_STD_ALLOCATOR
269           allocator_type allocator;
270 #  endif // BOOST_NO_STD_ALLOCATOR
271
272           if (op == clone_functor_tag) {
273             functor_type* f =
274               static_cast<functor_type*>(function_obj_ptr.obj_ptr);
275
276             // Clone the functor
277 #  ifndef BOOST_NO_STD_ALLOCATOR
278             pointer_type copy = allocator.allocate(1);
279             allocator.construct(copy, *f);
280
281             // Get back to the original pointer type
282             functor_type* new_f = static_cast<functor_type*>(copy);
283 #  else
284             functor_type* new_f = new functor_type(*f);
285 #  endif // BOOST_NO_STD_ALLOCATOR
286             return make_any_pointer(static_cast<void*>(new_f));
287           }
288           else {
289             /* Cast from the void pointer to the functor pointer type */
290             functor_type* f =
291               reinterpret_cast<functor_type*>(function_obj_ptr.obj_ptr);
292
293 #  ifndef BOOST_NO_STD_ALLOCATOR
294             /* Cast from the functor pointer type to the allocator's pointer
295                type */
296             pointer_type victim = static_cast<pointer_type>(f);
297
298             // Destroy and deallocate the functor
299             allocator.destroy(victim);
300             allocator.deallocate(victim, 1);
301 #  else
302             delete f;
303 #  endif // BOOST_NO_STD_ALLOCATOR
304
305             return make_any_pointer(static_cast<void*>(0));
306           }
307         }
308       public:
309         /* Dispatch to an appropriate manager based on whether we have a
310            function pointer or a function object pointer. */
311         static any_pointer
312         manage(any_pointer functor_ptr, functor_manager_operation_type op)
313         {
314           if (op == check_functor_type_tag) {
315             std::type_info* type =
316               static_cast<std::type_info*>(functor_ptr.obj_ptr);
317             return (BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(Functor), *type)?
318                     functor_ptr
319                     : make_any_pointer(reinterpret_cast<void*>(0)));
320           }
321           else {
322             typedef typename get_function_tag<functor_type>::type tag_type;
323             return manager(functor_ptr, op, tag_type());
324           }
325         }
326       };
327
328       // A type that is only used for comparisons against zero
329       struct useless_clear_type {};
330
331 #ifdef BOOST_NO_SFINAE
332       // These routines perform comparisons between a Boost.Function
333       // object and an arbitrary function object (when the last
334       // parameter is mpl::bool_<false>) or against zero (when the
335       // last parameter is mpl::bool_<true>). They are only necessary
336       // for compilers that don't support SFINAE.
337       template<typename Function, typename Functor>
338         bool
339         compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
340         { return f.empty(); }
341
342       template<typename Function, typename Functor>
343         bool
344         compare_not_equal(const Function& f, const Functor&, int,
345                           mpl::bool_<true>)
346         { return !f.empty(); }
347
348       template<typename Function, typename Functor>
349         bool
350         compare_equal(const Function& f, const Functor& g, long,
351                       mpl::bool_<false>)
352         {
353           if (const Functor* fp = f.template target<Functor>())
354             return function_equal(*fp, g);
355           else return false;
356         }
357
358       template<typename Function, typename Functor>
359         bool
360         compare_equal(const Function& f, const reference_wrapper<Functor>& g,
361                       int, mpl::bool_<false>)
362         {
363           if (const Functor* fp = f.template target<Functor>())
364             return fp == g.get_pointer();
365           else return false;
366         }
367
368       template<typename Function, typename Functor>
369         bool
370         compare_not_equal(const Function& f, const Functor& g, long,
371                           mpl::bool_<false>)
372         {
373           if (const Functor* fp = f.template target<Functor>())
374             return !function_equal(*fp, g);
375           else return true;
376         }
377
378       template<typename Function, typename Functor>
379         bool
380         compare_not_equal(const Function& f,
381                           const reference_wrapper<Functor>& g, int,
382                           mpl::bool_<false>)
383         {
384           if (const Functor* fp = f.template target<Functor>())
385             return fp != g.get_pointer();
386           else return true;
387         }
388 #endif // BOOST_NO_SFINAE
389     } // end namespace function
390   } // end namespace detail
391
392 /**
393  * The function_base class contains the basic elements needed for the
394  * function1, function2, function3, etc. classes. It is common to all
395  * functions (and as such can be used to tell if we have one of the
396  * functionN objects).
397  */
398 class function_base
399 {
400 public:
401   function_base() : manager(0)
402   {
403     functor.obj_ptr = 0;
404   }
405
406   // Is this function empty?
407   bool empty() const { return !manager; }
408
409   template<typename Functor>
410     Functor* target()
411     {
412       if (!manager) return 0;
413
414       detail::function::any_pointer result =
415         manager(detail::function::make_any_pointer(&typeid(Functor)),
416                 detail::function::check_functor_type_tag);
417       if (!result.obj_ptr) return 0;
418       else {
419         typedef typename detail::function::get_function_tag<Functor>::type tag;
420         return get_functor_pointer<Functor>(tag(), 0);
421       }
422     }
423
424   template<typename Functor>
425
426 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
427     const Functor* target( Functor * = 0 ) const
428 #else
429     const Functor* target() const
430 #endif
431     {
432       if (!manager) return 0;
433
434       detail::function::any_pointer result =
435         manager(detail::function::make_any_pointer(&typeid(Functor)),
436                 detail::function::check_functor_type_tag);
437       if (!result.obj_ptr) return 0;
438       else {
439         typedef typename detail::function::get_function_tag<Functor>::type tag;
440
441 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
442         return get_functor_pointer(tag(), 0, (Functor*)0);
443 #else
444         return get_functor_pointer<Functor>(tag(), 0);
445 #endif
446       }
447     }
448
449   template<typename F>
450     bool contains(const F& f) const
451     {
452 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
453       if (const F* fp = this->target( (F*)0 )) {
454 #else
455       if (const F* fp = this->template target<F>()) {
456 #endif
457         return function_equal(*fp, f);
458       } else {
459         return false;
460       }
461     }
462
463 #if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
464   // GCC 3.3 and newer cannot copy with the global operator==, due to
465   // problems with instantiation of function return types before it
466   // has been verified that the argument types match up.
467   template<typename Functor>
468     BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
469     operator==(Functor g) const
470     {
471       if (const Functor* fp = target<Functor>())
472         return function_equal(*fp, g);
473       else return false;
474     }
475
476   template<typename Functor>
477     BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
478     operator!=(Functor g) const
479     {
480       if (const Functor* fp = target<Functor>())
481         return !function_equal(*fp, g);
482       else return true;
483     }
484 #endif
485
486 public: // should be protected, but GCC 2.95.3 will fail to allow access
487   detail::function::any_pointer (*manager)(
488     detail::function::any_pointer,
489     detail::function::functor_manager_operation_type);
490   detail::function::any_pointer functor;
491
492 private:
493   template<typename Functor>
494 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
495     Functor* get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0)
496 #else
497     Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
498 #endif
499     { return reinterpret_cast<Functor*>(&functor.func_ptr); }
500
501   template<typename Functor, typename Tag>
502 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
503     Functor* get_functor_pointer(Tag, long, Functor * = 0)
504 #else
505     Functor* get_functor_pointer(Tag, long)
506 #endif
507     { return static_cast<Functor*>(functor.obj_ptr); }
508
509   template<typename Functor>
510     const Functor*
511 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
512     get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0) const
513 #else
514     get_functor_pointer(detail::function::function_ptr_tag, int) const
515 #endif
516     { return reinterpret_cast<const Functor*>(&functor.func_ptr); }
517
518   template<typename Functor, typename Tag>
519 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
520     const Functor* get_functor_pointer(Tag, long, Functor * = 0) const
521 #else
522     const Functor* get_functor_pointer(Tag, long) const
523 #endif
524     { return static_cast<const Functor*>(functor.const_obj_ptr); }
525 };
526
527 /**
528  * The bad_function_call exception class is thrown when a boost::function
529  * object is invoked
530  */
531 class bad_function_call : public std::runtime_error
532 {
533 public:
534   bad_function_call() : std::runtime_error("call to empty boost::function") {}
535 };
536
537 #ifndef BOOST_NO_SFINAE
538 inline bool operator==(const function_base& f,
539                        detail::function::useless_clear_type*)
540 {
541   return f.empty();
542 }
543
544 inline bool operator!=(const function_base& f,
545                        detail::function::useless_clear_type*)
546 {
547   return !f.empty();
548 }
549
550 inline bool operator==(detail::function::useless_clear_type*,
551                        const function_base& f)
552 {
553   return f.empty();
554 }
555
556 inline bool operator!=(detail::function::useless_clear_type*,
557                        const function_base& f)
558 {
559   return !f.empty();
560 }
561 #endif
562
563 #ifdef BOOST_NO_SFINAE
564 // Comparisons between boost::function objects and arbitrary function objects
565 template<typename Functor>
566   inline bool operator==(const function_base& f, Functor g)
567   {
568     typedef mpl::bool_<(is_integral<Functor>::value)> integral;
569     return detail::function::compare_equal(f, g, 0, integral());
570   }
571
572 template<typename Functor>
573   inline bool operator==(Functor g, const function_base& f)
574   {
575     typedef mpl::bool_<(is_integral<Functor>::value)> integral;
576     return detail::function::compare_equal(f, g, 0, integral());
577   }
578
579 template<typename Functor>
580   inline bool operator!=(const function_base& f, Functor g)
581   {
582     typedef mpl::bool_<(is_integral<Functor>::value)> integral;
583     return detail::function::compare_not_equal(f, g, 0, integral());
584   }
585
586 template<typename Functor>
587   inline bool operator!=(Functor g, const function_base& f)
588   {
589     typedef mpl::bool_<(is_integral<Functor>::value)> integral;
590     return detail::function::compare_not_equal(f, g, 0, integral());
591   }
592 #else
593
594 #  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
595 // Comparisons between boost::function objects and arbitrary function
596 // objects. GCC 3.3 and before has an obnoxious bug that prevents this
597 // from working.
598 template<typename Functor>
599   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
600   operator==(const function_base& f, Functor g)
601   {
602     if (const Functor* fp = f.template target<Functor>())
603       return function_equal(*fp, g);
604     else return false;
605   }
606
607 template<typename Functor>
608   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
609   operator==(Functor g, const function_base& f)
610   {
611     if (const Functor* fp = f.template target<Functor>())
612       return function_equal(g, *fp);
613     else return false;
614   }
615
616 template<typename Functor>
617   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
618   operator!=(const function_base& f, Functor g)
619   {
620     if (const Functor* fp = f.template target<Functor>())
621       return !function_equal(*fp, g);
622     else return true;
623   }
624
625 template<typename Functor>
626   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
627   operator!=(Functor g, const function_base& f)
628   {
629     if (const Functor* fp = f.template target<Functor>())
630       return !function_equal(g, *fp);
631     else return true;
632   }
633 #  endif
634
635 template<typename Functor>
636   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
637   operator==(const function_base& f, reference_wrapper<Functor> g)
638   {
639     if (const Functor* fp = f.template target<Functor>())
640       return fp == g.get_pointer();
641     else return false;
642   }
643
644 template<typename Functor>
645   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
646   operator==(reference_wrapper<Functor> g, const function_base& f)
647   {
648     if (const Functor* fp = f.template target<Functor>())
649       return g.get_pointer() == fp;
650     else return false;
651   }
652
653 template<typename Functor>
654   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
655   operator!=(const function_base& f, reference_wrapper<Functor> g)
656   {
657     if (const Functor* fp = f.template target<Functor>())
658       return fp != g.get_pointer();
659     else return true;
660   }
661
662 template<typename Functor>
663   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
664   operator!=(reference_wrapper<Functor> g, const function_base& f)
665   {
666     if (const Functor* fp = f.template target<Functor>())
667       return g.get_pointer() != fp;
668     else return true;
669   }
670
671 #endif // Compiler supporting SFINAE
672
673 namespace detail {
674   namespace function {
675     inline bool has_empty_target(const function_base* f)
676     {
677       return f->empty();
678     }
679
680 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
681     inline bool has_empty_target(const void*)
682     {
683       return false;
684     }
685 #else
686     inline bool has_empty_target(...)
687     {
688       return false;
689     }
690 #endif
691   } // end namespace function
692 } // end namespace detail
693 } // end namespace boost
694
695 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
696 #undef BOOST_FUNCTION_COMPARE_TYPE_ID
697
698 #endif // BOOST_FUNCTION_BASE_HEADER