1 // Boost.Function library

     2 

     3 //  Copyright Douglas Gregor 2001-2006. 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 // Note: this header is a header template and must NOT have multiple-inclusion

    11 // protection.

    12 #include <boost/function/detail/prologue.hpp>

    13 

    14 #define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

    15 

    16 #define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

    17 

    18 #define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

    19 

    20 #define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

    21 

    22 #define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

    23 

    24 #define BOOST_FUNCTION_ARG_TYPE(J,I,D) \

    25   typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);

    26 

    27 #define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)

    28 

    29 // Type of the default allocator

    30 #ifndef BOOST_NO_STD_ALLOCATOR

    31 #  define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>

    32 #else

    33 #  define BOOST_FUNCTION_DEFAULT_ALLOCATOR int

    34 #endif // BOOST_NO_STD_ALLOCATOR

    35 

    36 // Comma if nonzero number of arguments

    37 #if BOOST_FUNCTION_NUM_ARGS == 0

    38 #  define BOOST_FUNCTION_COMMA

    39 #else

    40 #  define BOOST_FUNCTION_COMMA ,

    41 #endif // BOOST_FUNCTION_NUM_ARGS > 0

    42 

    43 // Class names used in this version of the code

    44 #define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)

    45 #define BOOST_FUNCTION_FUNCTION_INVOKER \

    46   BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

    47 #define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \

    48   BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

    49 #define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \

    50   BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

    51 #define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \

    52   BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

    53 #define BOOST_FUNCTION_FUNCTION_REF_INVOKER \

    54   BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

    55 #define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \

    56   BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

    57 #define BOOST_FUNCTION_GET_FUNCTION_INVOKER \

    58   BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

    59 #define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \

    60   BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

    61 #define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \

    62   BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

    63 #define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)

    64 

    65 #ifndef BOOST_NO_VOID_RETURNS

    66 #  define BOOST_FUNCTION_VOID_RETURN_TYPE void

    67 #  define BOOST_FUNCTION_RETURN(X) X

    68 #else

    69 #  define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable

    70 #  define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()

    71 #endif

    72 

    73 #ifdef BOOST_MSVC

    74 #  pragma warning(push)

    75 #  pragma warning(disable: 4127) // conditional expression is constant.

    76 #endif

    77 

    78 #ifdef BOOST_MSVC

    79 #  pragma warning(push)

    80 #  pragma warning(disable: 4127) // conditional expression is constant.

    81 #endif

    82 

    83 namespace boost {

    84   namespace detail {

    85     namespace function {

    86       template<

    87         typename FunctionPtr,

    88         typename R BOOST_FUNCTION_COMMA

    89         BOOST_FUNCTION_TEMPLATE_PARMS

    90         >

    91       struct BOOST_FUNCTION_FUNCTION_INVOKER

    92       {

    93         static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA

    94                         BOOST_FUNCTION_PARMS)

    95         {

    96           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);

    97           return f(BOOST_FUNCTION_ARGS);

    98         }

    99       };

   100 

   101       template<

   102         typename FunctionPtr,

   103         typename R BOOST_FUNCTION_COMMA

   104         BOOST_FUNCTION_TEMPLATE_PARMS

   105         >

   106       struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER

   107       {

   108         static BOOST_FUNCTION_VOID_RETURN_TYPE

   109         invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA

   110                BOOST_FUNCTION_PARMS)

   111 

   112         {

   113           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);

   114           BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));

   115         }

   116       };

   117 

   118       template<

   119         typename FunctionObj,

   120         typename R BOOST_FUNCTION_COMMA

   121         BOOST_FUNCTION_TEMPLATE_PARMS

   122       >

   123       struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER

   124       {

   125         static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

   126                         BOOST_FUNCTION_PARMS)

   127 

   128         {

   129           FunctionObj* f;

   130           if (function_allows_small_object_optimization<FunctionObj>::value)

   131             f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);

   132           else

   133             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

   134           return (*f)(BOOST_FUNCTION_ARGS);

   135         }

   136       };

   137 

   138       template<

   139         typename FunctionObj,

   140         typename R BOOST_FUNCTION_COMMA

   141         BOOST_FUNCTION_TEMPLATE_PARMS

   142       >

   143       struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER

   144       {

   145         static BOOST_FUNCTION_VOID_RETURN_TYPE

   146         invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

   147                BOOST_FUNCTION_PARMS)

   148 

   149         {

   150           FunctionObj* f;

   151           if (function_allows_small_object_optimization<FunctionObj>::value)

   152             f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);

   153           else

   154             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

   155           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));

   156         }

   157       };

   158 

   159       template<

   160         typename FunctionObj,

   161         typename R BOOST_FUNCTION_COMMA

   162         BOOST_FUNCTION_TEMPLATE_PARMS

   163       >

   164       struct BOOST_FUNCTION_FUNCTION_REF_INVOKER

   165       {

   166         static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

   167                         BOOST_FUNCTION_PARMS)

   168 

   169         {

   170           FunctionObj* f = 

   171             reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

   172           return (*f)(BOOST_FUNCTION_ARGS);

   173         }

   174       };

   175 

   176       template<

   177         typename FunctionObj,

   178         typename R BOOST_FUNCTION_COMMA

   179         BOOST_FUNCTION_TEMPLATE_PARMS

   180       >

   181       struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER

   182       {

   183         static BOOST_FUNCTION_VOID_RETURN_TYPE

   184         invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

   185                BOOST_FUNCTION_PARMS)

   186 

   187         {

   188           FunctionObj* f = 

   189             reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

   190           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));

   191         }

   192       };

   193 

   194       template<

   195         typename FunctionPtr,

   196         typename R BOOST_FUNCTION_COMMA

   197         BOOST_FUNCTION_TEMPLATE_PARMS

   198       >

   199       struct BOOST_FUNCTION_GET_FUNCTION_INVOKER

   200       {

   201         typedef typename mpl::if_c<(is_void<R>::value),

   202                             BOOST_FUNCTION_VOID_FUNCTION_INVOKER<

   203                             FunctionPtr,

   204                             R BOOST_FUNCTION_COMMA

   205                             BOOST_FUNCTION_TEMPLATE_ARGS

   206                           >,

   207                           BOOST_FUNCTION_FUNCTION_INVOKER<

   208                             FunctionPtr,

   209                             R BOOST_FUNCTION_COMMA

   210                             BOOST_FUNCTION_TEMPLATE_ARGS

   211                           >

   212                        >::type type;

   213       };

   214 

   215       template<

   216         typename FunctionObj,

   217         typename R BOOST_FUNCTION_COMMA

   218         BOOST_FUNCTION_TEMPLATE_PARMS

   219        >

   220       struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER

   221       {

   222         typedef typename mpl::if_c<(is_void<R>::value),

   223                             BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<

   224                             FunctionObj,

   225                             R BOOST_FUNCTION_COMMA

   226                             BOOST_FUNCTION_TEMPLATE_ARGS

   227                           >,

   228                           BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<

   229                             FunctionObj,

   230                             R BOOST_FUNCTION_COMMA

   231                             BOOST_FUNCTION_TEMPLATE_ARGS

   232                           >

   233                        >::type type;

   234       };

   235 

   236       template<

   237         typename FunctionObj,

   238         typename R BOOST_FUNCTION_COMMA

   239         BOOST_FUNCTION_TEMPLATE_PARMS

   240        >

   241       struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER

   242       {

   243         typedef typename mpl::if_c<(is_void<R>::value),

   244                             BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<

   245                             FunctionObj,

   246                             R BOOST_FUNCTION_COMMA

   247                             BOOST_FUNCTION_TEMPLATE_ARGS

   248                           >,

   249                           BOOST_FUNCTION_FUNCTION_REF_INVOKER<

   250                             FunctionObj,

   251                             R BOOST_FUNCTION_COMMA

   252                             BOOST_FUNCTION_TEMPLATE_ARGS

   253                           >

   254                        >::type type;

   255       };

   256 

   257       /**

   258        * vtable for a specific boost::function instance.

   259        */

   260       template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,

   261                typename Allocator>

   262       struct BOOST_FUNCTION_VTABLE : vtable_base

   263       {

   264 #ifndef BOOST_NO_VOID_RETURNS

   265         typedef R         result_type;

   266 #else

   267         typedef typename function_return_type<R>::type result_type;

   268 #endif // BOOST_NO_VOID_RETURNS

   269 

   270         typedef result_type (*invoker_type)(function_buffer&

   271                                             BOOST_FUNCTION_COMMA

   272                                             BOOST_FUNCTION_TEMPLATE_ARGS);

   273 

   274         template<typename F>

   275         BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)

   276         {

   277           init(f);

   278         }

   279 

   280         template<typename F>

   281         bool assign_to(F f, function_buffer& functor)

   282         {

   283           typedef typename get_function_tag<F>::type tag;

   284           return assign_to(f, functor, tag());

   285         }

   286 

   287         void clear(function_buffer& functor)

   288         {

   289           if (manager)

   290             manager(functor, functor, destroy_functor_tag);

   291         }

   292 

   293       private:

   294         template<typename F>

   295         void init(F f)

   296         {

   297           typedef typename get_function_tag<F>::type tag;

   298           init(f, tag());

   299         }

   300 

   301         // Function pointers

   302         template<typename FunctionPtr>

   303         void init(FunctionPtr /*f*/, function_ptr_tag)

   304         {

   305           typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<

   306                              FunctionPtr,

   307                              R BOOST_FUNCTION_COMMA

   308                              BOOST_FUNCTION_TEMPLATE_ARGS

   309                            >::type

   310             actual_invoker_type;

   311 

   312           invoker = &actual_invoker_type::invoke;

   313           manager = &functor_manager<FunctionPtr, Allocator>::manage;

   314         }

   315 

   316         template<typename FunctionPtr>

   317         bool 

   318         assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)

   319         {

   320           this->clear(functor);

   321           if (f) {

   322             // should be a reinterpret cast, but some compilers insist

   323             // on giving cv-qualifiers to free functions

   324             functor.func_ptr = (void (*)())(f);

   325             return true;

   326           } else {

   327             return false;

   328           }

   329         }

   330 

   331         // Member pointers

   332 #if BOOST_FUNCTION_NUM_ARGS > 0

   333         template<typename MemberPtr>

   334         void init(MemberPtr f, member_ptr_tag)

   335         {

   336           // DPG TBD: Add explicit support for member function

   337           // objects, so we invoke through mem_fn() but we retain the

   338           // right target_type() values.

   339           this->init(mem_fn(f));

   340         }

   341 

   342         template<typename MemberPtr>

   343         bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)

   344         {

   345           // DPG TBD: Add explicit support for member function

   346           // objects, so we invoke through mem_fn() but we retain the

   347           // right target_type() values.

   348           if (f) {

   349             this->assign_to(mem_fn(f), functor);

   350             return true;

   351           } else {

   352             return false;

   353           }

   354         }

   355 #endif // BOOST_FUNCTION_NUM_ARGS > 0

   356 

   357         // Function objects

   358         template<typename FunctionObj>

   359         void init(FunctionObj /*f*/, function_obj_tag)

   360         {

   361           typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<

   362                              FunctionObj,

   363                              R BOOST_FUNCTION_COMMA

   364                              BOOST_FUNCTION_TEMPLATE_ARGS

   365                            >::type

   366             actual_invoker_type;

   367 

   368           invoker = &actual_invoker_type::invoke;

   369           manager = &functor_manager<FunctionObj, Allocator>::manage;

   370         }

   371 

   372         // Assign to a function object using the small object optimization

   373         template<typename FunctionObj>

   374         void 

   375         assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)

   376         {

   377           new ((void*)&functor.data) FunctionObj(f);

   378         }

   379 

   380         // Assign to a function object allocated on the heap.

   381         template<typename FunctionObj>

   382         void 

   383         assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)

   384         {

   385 #ifndef BOOST_NO_STD_ALLOCATOR

   386           typedef typename Allocator::template rebind<FunctionObj>::other

   387             allocator_type;

   388           typedef typename allocator_type::pointer pointer_type;

   389 

   390           allocator_type allocator;

   391           pointer_type copy = allocator.allocate(1);

   392           allocator.construct(copy, f);

   393 

   394           // Get back to the original pointer type

   395           functor.obj_ptr = static_cast<FunctionObj*>(copy);

   396 #  else

   397           functor.obj_ptr = new FunctionObj(f);

   398 #  endif // BOOST_NO_STD_ALLOCATOR

   399         }

   400 

   401         template<typename FunctionObj>

   402         bool 

   403         assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)

   404         {

   405           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {

   406             assign_functor(f, functor, 

   407                            mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());

   408             return true;

   409           } else {

   410             return false;

   411           }

   412         }

   413 

   414         // Reference to a function object

   415         template<typename FunctionObj>

   416         void 

   417         init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)

   418         {

   419           typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<

   420                              FunctionObj,

   421                              R BOOST_FUNCTION_COMMA

   422                              BOOST_FUNCTION_TEMPLATE_ARGS

   423                            >::type

   424             actual_invoker_type;

   425 

   426           invoker = &actual_invoker_type::invoke;

   427           manager = &reference_manager<FunctionObj>::get;

   428         }

   429 

   430         template<typename FunctionObj>

   431         bool 

   432         assign_to(const reference_wrapper<FunctionObj>& f, 

   433                   function_buffer& functor, function_obj_ref_tag)

   434         {

   435           if (!boost::detail::function::has_empty_target(f.get_pointer())) {

   436             // DPG TBD: We might need to detect constness of

   437             // FunctionObj to assign into obj_ptr or const_obj_ptr to

   438             // be truly legit, but no platform in existence makes

   439             // const void* different from void*.

   440             functor.const_obj_ptr = f.get_pointer();

   441             return true;

   442           } else {

   443             return false;

   444           }

   445         }

   446 

   447       public:

   448         invoker_type invoker;

   449       };

   450     } // end namespace function

   451   } // end namespace detail

   452 

   453   template<

   454     typename R BOOST_FUNCTION_COMMA

   455     BOOST_FUNCTION_TEMPLATE_PARMS,

   456     typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR

   457   >

   458   class BOOST_FUNCTION_FUNCTION : public function_base

   459   {

   460   public:

   461 #ifndef BOOST_NO_VOID_RETURNS

   462     typedef R         result_type;

   463 #else

   464     typedef  typename boost::detail::function::function_return_type<R>::type

   465       result_type;

   466 #endif // BOOST_NO_VOID_RETURNS

   467 

   468   private:

   469     typedef boost::detail::function::BOOST_FUNCTION_VTABLE<

   470               R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>

   471       vtable_type;

   472 

   473     struct clear_type {};

   474 

   475   public:

   476     BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);

   477 

   478     // add signature for boost::lambda

   479     template<typename Args>

   480     struct sig

   481     {

   482       typedef result_type type;

   483     };

   484 

   485 #if BOOST_FUNCTION_NUM_ARGS == 1

   486     typedef T0 argument_type;

   487 #elif BOOST_FUNCTION_NUM_ARGS == 2

   488     typedef T0 first_argument_type;

   489     typedef T1 second_argument_type;

   490 #endif

   491 

   492     BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);

   493     BOOST_FUNCTION_ARG_TYPES

   494 

   495     typedef Allocator allocator_type;

   496     typedef BOOST_FUNCTION_FUNCTION self_type;

   497 

   498     BOOST_FUNCTION_FUNCTION() : function_base() { }

   499 

   500     // MSVC chokes if the following two constructors are collapsed into

   501     // one with a default parameter.

   502     template<typename Functor>

   503     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f

   504 #ifndef BOOST_NO_SFINAE

   505                             ,typename enable_if_c<

   506                             (boost::type_traits::ice_not<

   507                              (is_integral<Functor>::value)>::value),

   508                                         int>::type = 0

   509 #endif // BOOST_NO_SFINAE

   510                             ) :

   511       function_base()

   512     {

   513       this->assign_to(f);

   514     }

   515 

   516 #ifndef BOOST_NO_SFINAE

   517     BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }

   518 #else

   519     BOOST_FUNCTION_FUNCTION(int zero) : function_base()

   520     {

   521       BOOST_ASSERT(zero == 0);

   522     }

   523 #endif

   524 

   525     BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()

   526     {

   527       this->assign_to_own(f);

   528     }

   529 

   530     ~BOOST_FUNCTION_FUNCTION() { clear(); }

   531 

   532 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)

   533     // MSVC 6.0 and prior require all definitions to be inline, but

   534     // these definitions can become very costly.

   535     result_type operator()(BOOST_FUNCTION_PARMS) const

   536     {

   537       if (this->empty())

   538         boost::throw_exception(bad_function_call());

   539 

   540       return static_cast<vtable_type*>(vtable)->invoker

   541                (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);

   542     }

   543 #else

   544     result_type operator()(BOOST_FUNCTION_PARMS) const;

   545 #endif

   546 

   547     // The distinction between when to use BOOST_FUNCTION_FUNCTION and

   548     // when to use self_type is obnoxious. MSVC cannot handle self_type as

   549     // the return type of these assignment operators, but Borland C++ cannot

   550     // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to

   551     // construct.

   552     template<typename Functor>

   553 #ifndef BOOST_NO_SFINAE

   554     typename enable_if_c<

   555                (boost::type_traits::ice_not<

   556                  (is_integral<Functor>::value)>::value),

   557                BOOST_FUNCTION_FUNCTION&>::type

   558 #else

   559     BOOST_FUNCTION_FUNCTION&

   560 #endif

   561     operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)

   562     {

   563       this->clear();

   564       try {

   565         this->assign_to(f);

   566       } catch (...) {

   567         vtable = 0;

   568         throw;

   569       }

   570       return *this;

   571     }

   572 

   573 #ifndef BOOST_NO_SFINAE

   574     BOOST_FUNCTION_FUNCTION& operator=(clear_type*)

   575     {

   576       this->clear();

   577       return *this;

   578     }

   579 #else

   580     BOOST_FUNCTION_FUNCTION& operator=(int zero)

   581     {

   582       BOOST_ASSERT(zero == 0);

   583       this->clear();

   584       return *this;

   585     }

   586 #endif

   587 

   588     // Assignment from another BOOST_FUNCTION_FUNCTION

   589     BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)

   590     {

   591       if (&f == this)

   592         return *this;

   593 

   594       this->clear();

   595       try {

   596         this->assign_to_own(f);

   597       } catch (...) {

   598         vtable = 0;

   599         throw;

   600       }

   601       return *this;

   602     }

   603 

   604     void swap(BOOST_FUNCTION_FUNCTION& other)

   605     {

   606       if (&other == this)

   607         return;

   608 

   609       BOOST_FUNCTION_FUNCTION tmp = *this;

   610       *this = other;

   611       other = tmp;

   612     }

   613 

   614     // Clear out a target, if there is one

   615     void clear()

   616     {

   617       if (vtable) {

   618         static_cast<vtable_type*>(vtable)->clear(this->functor);

   619         vtable = 0;

   620       }

   621     }

   622 

   623 #if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)

   624     // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it

   625     operator bool () const { return !this->empty(); }

   626 #else

   627   private:

   628     struct dummy {

   629       void nonnull() {};

   630     };

   631 

   632     typedef void (dummy::*safe_bool)();

   633 

   634   public:

   635     operator safe_bool () const

   636       { return (this->empty())? 0 : &dummy::nonnull; }

   637 

   638     bool operator!() const

   639       { return this->empty(); }

   640 #endif

   641 

   642   private:

   643     void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)

   644     {

   645       if (!f.empty()) {

   646         this->vtable = f.vtable;

   647         f.vtable->manager(f.functor, this->functor,

   648                           boost::detail::function::clone_functor_tag);

   649       }

   650     }

   651 

   652     template<typename Functor>

   653     void assign_to(Functor f)

   654     {

   655       static vtable_type stored_vtable(f);

   656       if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;

   657       else vtable = 0;

   658     }

   659   };

   660 

   661   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,

   662            typename Allocator>

   663   inline void swap(BOOST_FUNCTION_FUNCTION<

   664                      R BOOST_FUNCTION_COMMA

   665                      BOOST_FUNCTION_TEMPLATE_ARGS ,

   666                      Allocator

   667                    >& f1,

   668                    BOOST_FUNCTION_FUNCTION<

   669                      R BOOST_FUNCTION_COMMA

   670                      BOOST_FUNCTION_TEMPLATE_ARGS,

   671                      Allocator

   672                    >& f2)

   673   {

   674     f1.swap(f2);

   675   }

   676 

   677 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

   678   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,

   679            typename Allocator>

   680   typename BOOST_FUNCTION_FUNCTION<

   681       R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,

   682       Allocator>::result_type

   683    BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,

   684 

   685                            Allocator>

   686   ::operator()(BOOST_FUNCTION_PARMS) const

   687   {

   688     if (this->empty())

   689       boost::throw_exception(bad_function_call());

   690 

   691     return static_cast<vtable_type*>(vtable)->invoker

   692              (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);

   693   }

   694 #endif

   695 

   696 // Poison comparisons between boost::function objects of the same type.

   697 template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,

   698          typename Allocator>

   699   void operator==(const BOOST_FUNCTION_FUNCTION<

   700                           R BOOST_FUNCTION_COMMA

   701                           BOOST_FUNCTION_TEMPLATE_ARGS ,

   702                           Allocator>&,

   703                   const BOOST_FUNCTION_FUNCTION<

   704                           R BOOST_FUNCTION_COMMA

   705                           BOOST_FUNCTION_TEMPLATE_ARGS ,

   706                   Allocator>&);

   707 template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,

   708          typename Allocator>

   709   void operator!=(const BOOST_FUNCTION_FUNCTION<

   710                           R BOOST_FUNCTION_COMMA

   711                           BOOST_FUNCTION_TEMPLATE_ARGS ,

   712                           Allocator>&,

   713                   const BOOST_FUNCTION_FUNCTION<

   714                           R BOOST_FUNCTION_COMMA

   715                           BOOST_FUNCTION_TEMPLATE_ARGS ,

   716                   Allocator>&);

   717 

   718 #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)

   719 

   720 #if BOOST_FUNCTION_NUM_ARGS == 0

   721 #define BOOST_FUNCTION_PARTIAL_SPEC R (void)

   722 #else

   723 #define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))

   724 #endif

   725 

   726 template<typename R BOOST_FUNCTION_COMMA

   727          BOOST_FUNCTION_TEMPLATE_PARMS,

   728          typename Allocator>

   729 class function<BOOST_FUNCTION_PARTIAL_SPEC, Allocator>

   730   : public BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS

   731                                    BOOST_FUNCTION_COMMA Allocator>

   732 {

   733   typedef BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS

   734                                   BOOST_FUNCTION_COMMA Allocator> base_type;

   735   typedef function self_type;

   736 

   737   struct clear_type {};

   738 

   739 public:

   740   typedef typename base_type::allocator_type allocator_type;

   741 

   742   function() : base_type() {}

   743 

   744   template<typename Functor>

   745   function(Functor f

   746 #ifndef BOOST_NO_SFINAE

   747            ,typename enable_if_c<

   748                             (boost::type_traits::ice_not<

   749                           (is_integral<Functor>::value)>::value),

   750                        int>::type = 0

   751 #endif

   752            ) :

   753     base_type(f)

   754   {

   755   }

   756 

   757 #ifndef BOOST_NO_SFINAE

   758   function(clear_type*) : base_type() {}

   759 #endif

   760 

   761   function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

   762 

   763   function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

   764 

   765   self_type& operator=(const self_type& f)

   766   {

   767     self_type(f).swap(*this);

   768     return *this;

   769   }

   770 

   771   template<typename Functor>

   772 #ifndef BOOST_NO_SFINAE

   773   typename enable_if_c<

   774                             (boost::type_traits::ice_not<

   775                          (is_integral<Functor>::value)>::value),

   776                       self_type&>::type

   777 #else

   778   self_type&

   779 #endif

   780   operator=(Functor f)

   781   {

   782     self_type(f).swap(*this);

   783     return *this;

   784   }

   785 

   786 #ifndef BOOST_NO_SFINAE

   787   self_type& operator=(clear_type*)

   788   {

   789     this->clear();

   790     return *this;

   791   }

   792 #endif

   793 

   794   self_type& operator=(const base_type& f)

   795   {

   796     self_type(f).swap(*this);

   797     return *this;

   798   }

   799 };

   800 

   801 #ifdef BOOST_MSVC

   802 # pragma warning(pop)

   803 #endif

   804 

   805 #undef BOOST_FUNCTION_PARTIAL_SPEC

   806 #endif // have partial specialization

   807 

   808 } // end namespace boost

   809 

   810 #ifdef BOOST_MSVC

   811 # pragma warning(pop)

   812 #endif

   813 

   814 // Cleanup after ourselves...

   815 #undef BOOST_FUNCTION_VTABLE

   816 #undef BOOST_FUNCTION_DEFAULT_ALLOCATOR

   817 #undef BOOST_FUNCTION_COMMA

   818 #undef BOOST_FUNCTION_FUNCTION

   819 #undef BOOST_FUNCTION_FUNCTION_INVOKER

   820 #undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER

   821 #undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER

   822 #undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER

   823 #undef BOOST_FUNCTION_FUNCTION_REF_INVOKER

   824 #undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER

   825 #undef BOOST_FUNCTION_GET_FUNCTION_INVOKER

   826 #undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER

   827 #undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER

   828 #undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER

   829 #undef BOOST_FUNCTION_TEMPLATE_PARMS

   830 #undef BOOST_FUNCTION_TEMPLATE_ARGS

   831 #undef BOOST_FUNCTION_PARMS

   832 #undef BOOST_FUNCTION_PARM

   833 #undef BOOST_FUNCTION_ARGS

   834 #undef BOOST_FUNCTION_ARG_TYPE

   835 #undef BOOST_FUNCTION_ARG_TYPES

   836 #undef BOOST_FUNCTION_VOID_RETURN_TYPE

   837 #undef BOOST_FUNCTION_RETURN