BVB Source Codes

mars Show function_template.hpp Source code

Return Download mars: download function_template.hpp Source code - Download mars Source code - Type:.hpp
  1. // Boost.Function library
  2.  
  3. //  Copyright Douglas Gregor 2001-2006
  4. //  Copyright Emil Dotchevski 2007
  5. //  Use, modification and distribution is subject to the Boost Software License, Version 1.0.
  6. //  (See accompanying file LICENSE_1_0.txt or copy at
  7. //  http://www.boost.org/LICENSE_1_0.txt)
  8.  
  9. // For more information, see http://www.boost.org
  10.  
  11. // Note: this header is a header template and must NOT have multiple-inclusion
  12. // protection.
  13. #include <boost/function/detail/prologue.hpp>
  14. #include <boost/detail/no_exceptions_support.hpp>
  15.  
  16. #if defined(BOOST_MSVC)
  17. #   pragma warning( push )
  18. #   pragma warning( disable : 4127 ) // "conditional expression is constant"
  19. #endif      
  20.  
  21. #define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
  22.  
  23. #define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
  24.  
  25. #define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
  26.  
  27. #define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
  28.  
  29. #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
  30. #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
  31. #else
  32. #   include <boost/move/utility_core.hpp>
  33. #   define BOOST_FUNCTION_ARG(J,I,D) ::mars_boost::forward< BOOST_PP_CAT(T,I) >(BOOST_PP_CAT(a,I))
  34. #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
  35. #endif
  36.  
  37. #define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
  38.   typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
  39.  
  40. #define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
  41.  
  42. // Comma if nonzero number of arguments
  43. #if BOOST_FUNCTION_NUM_ARGS == 0
  44. #  define BOOST_FUNCTION_COMMA
  45. #else
  46. #  define BOOST_FUNCTION_COMMA ,
  47. #endif // BOOST_FUNCTION_NUM_ARGS > 0
  48.  
  49. // Class names used in this version of the code
  50. #define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
  51. #define BOOST_FUNCTION_FUNCTION_INVOKER \
  52.   BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
  53. #define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
  54.   BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
  55. #define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
  56.   BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
  57. #define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
  58.   BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
  59. #define BOOST_FUNCTION_FUNCTION_REF_INVOKER \
  60.   BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
  61. #define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
  62.   BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
  63. #define BOOST_FUNCTION_MEMBER_INVOKER \
  64.   BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
  65. #define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
  66.   BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
  67. #define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
  68.   BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
  69. #define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
  70.   BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
  71. #define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
  72.   BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
  73. #define BOOST_FUNCTION_GET_MEMBER_INVOKER \
  74.   BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
  75. #define BOOST_FUNCTION_GET_INVOKER \
  76.   BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
  77. #define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
  78.  
  79. #ifndef BOOST_NO_VOID_RETURNS
  80. #  define BOOST_FUNCTION_VOID_RETURN_TYPE void
  81. #  define BOOST_FUNCTION_RETURN(X) X
  82. #else
  83. #  define BOOST_FUNCTION_VOID_RETURN_TYPE mars_boost::detail::function::unusable
  84. #  define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
  85. #endif
  86.  
  87. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  88.   namespace detail {
  89.     namespace function {
  90.       template<
  91.         typename FunctionPtr,
  92.         typename R BOOST_FUNCTION_COMMA
  93.         BOOST_FUNCTION_TEMPLATE_PARMS
  94.         >
  95.       struct BOOST_FUNCTION_FUNCTION_INVOKER
  96.       {
  97.         static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
  98.                         BOOST_FUNCTION_PARMS)
  99.         {
  100.           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
  101.           return f(BOOST_FUNCTION_ARGS);
  102.         }
  103.       };
  104.  
  105.       template<
  106.         typename FunctionPtr,
  107.         typename R BOOST_FUNCTION_COMMA
  108.         BOOST_FUNCTION_TEMPLATE_PARMS
  109.         >
  110.       struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
  111.       {
  112.         static BOOST_FUNCTION_VOID_RETURN_TYPE
  113.         invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
  114.                BOOST_FUNCTION_PARMS)
  115.  
  116.         {
  117.           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
  118.           BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
  119.         }
  120.       };
  121.  
  122.       template<
  123.         typename FunctionObj,
  124.         typename R BOOST_FUNCTION_COMMA
  125.         BOOST_FUNCTION_TEMPLATE_PARMS
  126.       >
  127.       struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
  128.       {
  129.         static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
  130.                         BOOST_FUNCTION_PARMS)
  131.  
  132.         {
  133.           FunctionObj* f;
  134.           if (function_allows_small_object_optimization<FunctionObj>::value)
  135.             f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
  136.           else
  137.             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
  138.           return (*f)(BOOST_FUNCTION_ARGS);
  139.         }
  140.       };
  141.  
  142.       template<
  143.         typename FunctionObj,
  144.         typename R BOOST_FUNCTION_COMMA
  145.         BOOST_FUNCTION_TEMPLATE_PARMS
  146.       >
  147.       struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
  148.       {
  149.         static BOOST_FUNCTION_VOID_RETURN_TYPE
  150.         invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
  151.                BOOST_FUNCTION_PARMS)
  152.  
  153.         {
  154.           FunctionObj* f;
  155.           if (function_allows_small_object_optimization<FunctionObj>::value)
  156.             f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
  157.           else
  158.             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
  159.           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
  160.         }
  161.       };
  162.  
  163.       template<
  164.         typename FunctionObj,
  165.         typename R BOOST_FUNCTION_COMMA
  166.         BOOST_FUNCTION_TEMPLATE_PARMS
  167.       >
  168.       struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
  169.       {
  170.         static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
  171.                         BOOST_FUNCTION_PARMS)
  172.  
  173.         {
  174.           FunctionObj* f =
  175.             reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
  176.           return (*f)(BOOST_FUNCTION_ARGS);
  177.         }
  178.       };
  179.  
  180.       template<
  181.         typename FunctionObj,
  182.         typename R BOOST_FUNCTION_COMMA
  183.         BOOST_FUNCTION_TEMPLATE_PARMS
  184.       >
  185.       struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
  186.       {
  187.         static BOOST_FUNCTION_VOID_RETURN_TYPE
  188.         invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
  189.                BOOST_FUNCTION_PARMS)
  190.  
  191.         {
  192.           FunctionObj* f =
  193.             reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
  194.           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
  195.         }
  196.       };
  197.  
  198. #if BOOST_FUNCTION_NUM_ARGS > 0
  199.       /* Handle invocation of member pointers. */
  200.       template<
  201.         typename MemberPtr,
  202.         typename R BOOST_FUNCTION_COMMA
  203.         BOOST_FUNCTION_TEMPLATE_PARMS
  204.       >
  205.       struct BOOST_FUNCTION_MEMBER_INVOKER
  206.       {
  207.         static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
  208.                         BOOST_FUNCTION_PARMS)
  209.  
  210.         {
  211.           MemberPtr* f =
  212.             reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
  213.           return mars_boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
  214.         }
  215.       };
  216.  
  217.       template<
  218.         typename MemberPtr,
  219.         typename R BOOST_FUNCTION_COMMA
  220.         BOOST_FUNCTION_TEMPLATE_PARMS
  221.       >
  222.       struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
  223.       {
  224.         static BOOST_FUNCTION_VOID_RETURN_TYPE
  225.         invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
  226.                BOOST_FUNCTION_PARMS)
  227.  
  228.         {
  229.           MemberPtr* f =
  230.             reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
  231.           BOOST_FUNCTION_RETURN(mars_boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
  232.         }
  233.       };
  234. #endif
  235.  
  236.       template<
  237.         typename FunctionPtr,
  238.         typename R BOOST_FUNCTION_COMMA
  239.         BOOST_FUNCTION_TEMPLATE_PARMS
  240.       >
  241.       struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
  242.       {
  243.         typedef typename mpl::if_c<(is_void<R>::value),
  244.                             BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
  245.                             FunctionPtr,
  246.                             R BOOST_FUNCTION_COMMA
  247.                             BOOST_FUNCTION_TEMPLATE_ARGS
  248.                           >,
  249.                           BOOST_FUNCTION_FUNCTION_INVOKER<
  250.                             FunctionPtr,
  251.                             R BOOST_FUNCTION_COMMA
  252.                             BOOST_FUNCTION_TEMPLATE_ARGS
  253.                           >
  254.                        >::type type;
  255.       };
  256.  
  257.       template<
  258.         typename FunctionObj,
  259.         typename R BOOST_FUNCTION_COMMA
  260.         BOOST_FUNCTION_TEMPLATE_PARMS
  261.        >
  262.       struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
  263.       {
  264.         typedef typename mpl::if_c<(is_void<R>::value),
  265.                             BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
  266.                             FunctionObj,
  267.                             R BOOST_FUNCTION_COMMA
  268.                             BOOST_FUNCTION_TEMPLATE_ARGS
  269.                           >,
  270.                           BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
  271.                             FunctionObj,
  272.                             R BOOST_FUNCTION_COMMA
  273.                             BOOST_FUNCTION_TEMPLATE_ARGS
  274.                           >
  275.                        >::type type;
  276.       };
  277.  
  278.       template<
  279.         typename FunctionObj,
  280.         typename R BOOST_FUNCTION_COMMA
  281.         BOOST_FUNCTION_TEMPLATE_PARMS
  282.        >
  283.       struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
  284.       {
  285.         typedef typename mpl::if_c<(is_void<R>::value),
  286.                             BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
  287.                             FunctionObj,
  288.                             R BOOST_FUNCTION_COMMA
  289.                             BOOST_FUNCTION_TEMPLATE_ARGS
  290.                           >,
  291.                           BOOST_FUNCTION_FUNCTION_REF_INVOKER<
  292.                             FunctionObj,
  293.                             R BOOST_FUNCTION_COMMA
  294.                             BOOST_FUNCTION_TEMPLATE_ARGS
  295.                           >
  296.                        >::type type;
  297.       };
  298.  
  299. #if BOOST_FUNCTION_NUM_ARGS > 0
  300.       /* Retrieve the appropriate invoker for a member pointer.  */
  301.       template<
  302.         typename MemberPtr,
  303.         typename R BOOST_FUNCTION_COMMA
  304.         BOOST_FUNCTION_TEMPLATE_PARMS
  305.        >
  306.       struct BOOST_FUNCTION_GET_MEMBER_INVOKER
  307.       {
  308.         typedef typename mpl::if_c<(is_void<R>::value),
  309.                             BOOST_FUNCTION_VOID_MEMBER_INVOKER<
  310.                             MemberPtr,
  311.                             R BOOST_FUNCTION_COMMA
  312.                             BOOST_FUNCTION_TEMPLATE_ARGS
  313.                           >,
  314.                           BOOST_FUNCTION_MEMBER_INVOKER<
  315.                             MemberPtr,
  316.                             R BOOST_FUNCTION_COMMA
  317.                             BOOST_FUNCTION_TEMPLATE_ARGS
  318.                           >
  319.                        >::type type;
  320.       };
  321. #endif
  322.  
  323.       /* Given the tag returned by get_function_tag, retrieve the
  324.          actual invoker that will be used for the given function
  325.          object.
  326.  
  327.          Each specialization contains an "apply" nested class template
  328.          that accepts the function object, return type, function
  329.          argument types, and allocator. The resulting "apply" class
  330.          contains two typedefs, "invoker_type" and "manager_type",
  331.          which correspond to the invoker and manager types. */
  332.       template<typename Tag>
  333.       struct BOOST_FUNCTION_GET_INVOKER { };
  334.  
  335.       /* Retrieve the invoker for a function pointer. */
  336.       template<>
  337.       struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
  338.       {
  339.         template<typename FunctionPtr,
  340.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  341.         struct apply
  342.         {
  343.           typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
  344.                              FunctionPtr,
  345.                              R BOOST_FUNCTION_COMMA
  346.                              BOOST_FUNCTION_TEMPLATE_ARGS
  347.                            >::type
  348.             invoker_type;
  349.  
  350.           typedef functor_manager<FunctionPtr> manager_type;
  351.         };
  352.  
  353.         template<typename FunctionPtr,
  354.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
  355.                  typename Allocator>
  356.         struct apply_a
  357.         {
  358.           typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
  359.                              FunctionPtr,
  360.                              R BOOST_FUNCTION_COMMA
  361.                              BOOST_FUNCTION_TEMPLATE_ARGS
  362.                            >::type
  363.             invoker_type;
  364.  
  365.           typedef functor_manager<FunctionPtr> manager_type;
  366.         };
  367.       };
  368.  
  369. #if BOOST_FUNCTION_NUM_ARGS > 0
  370.       /* Retrieve the invoker for a member pointer. */
  371.       template<>
  372.       struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
  373.       {
  374.         template<typename MemberPtr,
  375.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  376.         struct apply
  377.         {
  378.           typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
  379.                              MemberPtr,
  380.                              R BOOST_FUNCTION_COMMA
  381.                              BOOST_FUNCTION_TEMPLATE_ARGS
  382.                            >::type
  383.             invoker_type;
  384.  
  385.           typedef functor_manager<MemberPtr> manager_type;
  386.         };
  387.  
  388.         template<typename MemberPtr,
  389.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
  390.                  typename Allocator>
  391.         struct apply_a
  392.         {
  393.           typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
  394.                              MemberPtr,
  395.                              R BOOST_FUNCTION_COMMA
  396.                              BOOST_FUNCTION_TEMPLATE_ARGS
  397.                            >::type
  398.             invoker_type;
  399.  
  400.           typedef functor_manager<MemberPtr> manager_type;
  401.         };
  402.       };
  403. #endif
  404.  
  405.       /* Retrieve the invoker for a function object. */
  406.       template<>
  407.       struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
  408.       {
  409.         template<typename FunctionObj,
  410.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  411.         struct apply
  412.         {
  413.           typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
  414.                              FunctionObj,
  415.                              R BOOST_FUNCTION_COMMA
  416.                              BOOST_FUNCTION_TEMPLATE_ARGS
  417.                            >::type
  418.             invoker_type;
  419.  
  420.           typedef functor_manager<FunctionObj> manager_type;
  421.         };
  422.  
  423.         template<typename FunctionObj,
  424.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
  425.                  typename Allocator>
  426.         struct apply_a
  427.         {
  428.           typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
  429.                              FunctionObj,
  430.                              R BOOST_FUNCTION_COMMA
  431.                              BOOST_FUNCTION_TEMPLATE_ARGS
  432.                            >::type
  433.             invoker_type;
  434.  
  435.           typedef functor_manager_a<FunctionObj, Allocator> manager_type;
  436.         };
  437.       };
  438.  
  439.       /* Retrieve the invoker for a reference to a function object. */
  440.       template<>
  441.       struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
  442.       {
  443.         template<typename RefWrapper,
  444.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  445.         struct apply
  446.         {
  447.           typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
  448.                              typename RefWrapper::type,
  449.                              R BOOST_FUNCTION_COMMA
  450.                              BOOST_FUNCTION_TEMPLATE_ARGS
  451.                            >::type
  452.             invoker_type;
  453.  
  454.           typedef reference_manager<typename RefWrapper::type> manager_type;
  455.         };
  456.  
  457.         template<typename RefWrapper,
  458.                  typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
  459.                  typename Allocator>
  460.         struct apply_a
  461.         {
  462.           typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
  463.                              typename RefWrapper::type,
  464.                              R BOOST_FUNCTION_COMMA
  465.                              BOOST_FUNCTION_TEMPLATE_ARGS
  466.                            >::type
  467.             invoker_type;
  468.  
  469.           typedef reference_manager<typename RefWrapper::type> manager_type;
  470.         };
  471.       };
  472.  
  473.  
  474.       /**
  475.        * vtable for a specific mars_boost::function instance. This
  476.        * structure must be an aggregate so that we can use static
  477.        * initialization in mars_boost::function's assign_to and assign_to_a
  478.        * members. It therefore cannot have any constructors,
  479.        * destructors, base classes, etc.
  480.        */
  481.       template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  482.       struct BOOST_FUNCTION_VTABLE
  483.       {
  484. #ifndef BOOST_NO_VOID_RETURNS
  485.         typedef R         result_type;
  486. #else
  487.         typedef typename function_return_type<R>::type result_type;
  488. #endif // BOOST_NO_VOID_RETURNS
  489.  
  490.         typedef result_type (*invoker_type)(function_buffer&
  491.                                             BOOST_FUNCTION_COMMA
  492.                                             BOOST_FUNCTION_TEMPLATE_ARGS);
  493.  
  494.         template<typename F>
  495.         bool assign_to(F f, function_buffer& functor) const
  496.         {
  497.           typedef typename get_function_tag<F>::type tag;
  498.           return assign_to(f, functor, tag());
  499.         }
  500.         template<typename F,typename Allocator>
  501.         bool assign_to_a(F f, function_buffer& functor, Allocator a) const
  502.         {
  503.           typedef typename get_function_tag<F>::type tag;
  504.           return assign_to_a(f, functor, a, tag());
  505.         }
  506.  
  507.         void clear(function_buffer& functor) const
  508.         {
  509.           if (base.manager)
  510.             base.manager(functor, functor, destroy_functor_tag);
  511.         }
  512.  
  513.       private:
  514.         // Function pointers
  515.         template<typename FunctionPtr>
  516.         bool
  517.         assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
  518.         {
  519.           this->clear(functor);
  520.           if (f) {
  521.             // should be a reinterpret cast, but some compilers insist
  522.             // on giving cv-qualifiers to free functions
  523.             functor.func_ptr = reinterpret_cast<void (*)()>(f);
  524.             return true;
  525.           } else {
  526.             return false;
  527.           }
  528.         }
  529.         template<typename FunctionPtr,typename Allocator>
  530.         bool
  531.         assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
  532.         {
  533.           return assign_to(f,functor,function_ptr_tag());
  534.         }
  535.  
  536.         // Member pointers
  537. #if BOOST_FUNCTION_NUM_ARGS > 0
  538.         template<typename MemberPtr>
  539.         bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
  540.         {
  541.           // DPG TBD: Add explicit support for member function
  542.           // objects, so we invoke through mem_fn() but we retain the
  543.           // right target_type() values.
  544.           if (f) {
  545.             this->assign_to(mars_boost::mem_fn(f), functor);
  546.             return true;
  547.           } else {
  548.             return false;
  549.           }
  550.         }
  551.         template<typename MemberPtr,typename Allocator>
  552.         bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
  553.         {
  554.           // DPG TBD: Add explicit support for member function
  555.           // objects, so we invoke through mem_fn() but we retain the
  556.           // right target_type() values.
  557.           if (f) {
  558.             this->assign_to_a(mars_boost::mem_fn(f), functor, a);
  559.             return true;
  560.           } else {
  561.             return false;
  562.           }
  563.         }
  564. #endif // BOOST_FUNCTION_NUM_ARGS > 0
  565.  
  566.         // Function objects
  567.         // Assign to a function object using the small object optimization
  568.         template<typename FunctionObj>
  569.         void
  570.         assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
  571.         {
  572.           new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
  573.         }
  574.         template<typename FunctionObj,typename Allocator>
  575.         void
  576.         assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
  577.         {
  578.           assign_functor(f,functor,mpl::true_());
  579.         }
  580.  
  581.         // Assign to a function object allocated on the heap.
  582.         template<typename FunctionObj>
  583.         void
  584.         assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
  585.         {
  586.           functor.obj_ptr = new FunctionObj(f);
  587.         }
  588.         template<typename FunctionObj,typename Allocator>
  589.         void
  590.         assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
  591.         {
  592.           typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
  593.           typedef typename Allocator::template rebind<functor_wrapper_type>::other
  594.             wrapper_allocator_type;
  595.           typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
  596.           wrapper_allocator_type wrapper_allocator(a);
  597.           wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
  598.           wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
  599.           functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
  600.           functor.obj_ptr = new_f;
  601.         }
  602.  
  603.         template<typename FunctionObj>
  604.         bool
  605.         assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
  606.         {
  607.           if (!mars_boost::detail::function::has_empty_target(mars_boost::addressof(f))) {
  608.             assign_functor(f, functor,
  609.                            mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
  610.             return true;
  611.           } else {
  612.             return false;
  613.           }
  614.         }
  615.         template<typename FunctionObj,typename Allocator>
  616.         bool
  617.         assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
  618.         {
  619.           if (!mars_boost::detail::function::has_empty_target(mars_boost::addressof(f))) {
  620.             assign_functor_a(f, functor, a,
  621.                            mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
  622.             return true;
  623.           } else {
  624.             return false;
  625.           }
  626.         }
  627.  
  628.         // Reference to a function object
  629.         template<typename FunctionObj>
  630.         bool
  631.         assign_to(const reference_wrapper<FunctionObj>& f,
  632.                   function_buffer& functor, function_obj_ref_tag) const
  633.         {
  634.           functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
  635.           functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
  636.           functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
  637.           return true;
  638.         }
  639.         template<typename FunctionObj,typename Allocator>
  640.         bool
  641.         assign_to_a(const reference_wrapper<FunctionObj>& f,
  642.                   function_buffer& functor, Allocator, function_obj_ref_tag) const
  643.         {
  644.           return assign_to(f,functor,function_obj_ref_tag());
  645.         }
  646.  
  647.       public:
  648.         vtable_base base;
  649.         invoker_type invoker;
  650.       };
  651.     } // end namespace function
  652.   } // end namespace detail
  653.  
  654.   template<
  655.     typename R BOOST_FUNCTION_COMMA
  656.     BOOST_FUNCTION_TEMPLATE_PARMS
  657.   >
  658.   class BOOST_FUNCTION_FUNCTION : public function_base
  659.  
  660. #if BOOST_FUNCTION_NUM_ARGS == 1
  661.  
  662.     , public std::unary_function<T0,R>
  663.  
  664. #elif BOOST_FUNCTION_NUM_ARGS == 2
  665.  
  666.     , public std::binary_function<T0,T1,R>
  667.  
  668. #endif
  669.  
  670.   {
  671.   public:
  672. #ifndef BOOST_NO_VOID_RETURNS
  673.     typedef R         result_type;
  674. #else
  675.     typedef  typename mars_boost::detail::function::function_return_type<R>::type
  676.       result_type;
  677. #endif // BOOST_NO_VOID_RETURNS
  678.  
  679.   private:
  680.     typedef mars_boost::detail::function::BOOST_FUNCTION_VTABLE<
  681.               R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
  682.       vtable_type;
  683.  
  684.     vtable_type* get_vtable() const {
  685.       return reinterpret_cast<vtable_type*>(
  686.                reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
  687.     }
  688.  
  689.     struct clear_type {};
  690.  
  691.   public:
  692.     BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
  693.  
  694.     // add signature for mars_boost::lambda
  695.     template<typename Args>
  696.     struct sig
  697.     {
  698.       typedef result_type type;
  699.     };
  700.  
  701. #if BOOST_FUNCTION_NUM_ARGS == 1
  702.     typedef T0 argument_type;
  703. #elif BOOST_FUNCTION_NUM_ARGS == 2
  704.     typedef T0 first_argument_type;
  705.     typedef T1 second_argument_type;
  706. #endif
  707.  
  708.     BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
  709.     BOOST_FUNCTION_ARG_TYPES
  710.  
  711.     typedef BOOST_FUNCTION_FUNCTION self_type;
  712.  
  713.     BOOST_FUNCTION_FUNCTION() : function_base() { }
  714.  
  715.     // MSVC chokes if the following two constructors are collapsed into
  716.     // one with a default parameter.
  717.     template<typename Functor>
  718.     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
  719. #ifndef BOOST_NO_SFINAE
  720.                             ,typename mars_boost::enable_if_c<
  721.                              !(is_integral<Functor>::value),
  722.                                         int>::type = 0
  723. #endif // BOOST_NO_SFINAE
  724.                             ) :
  725.       function_base()
  726.     {
  727.       this->assign_to(f);
  728.     }
  729.     template<typename Functor,typename Allocator>
  730.     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
  731. #ifndef BOOST_NO_SFINAE
  732.                             ,typename mars_boost::enable_if_c<
  733.                               !(is_integral<Functor>::value),
  734.                                         int>::type = 0
  735. #endif // BOOST_NO_SFINAE
  736.                             ) :
  737.       function_base()
  738.     {
  739.       this->assign_to_a(f,a);
  740.     }
  741.  
  742. #ifndef BOOST_NO_SFINAE
  743.     BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
  744. #else
  745.     BOOST_FUNCTION_FUNCTION(int zero) : function_base()
  746.     {
  747.       BOOST_ASSERT(zero == 0);
  748.     }
  749. #endif
  750.  
  751.     BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
  752.     {
  753.       this->assign_to_own(f);
  754.     }
  755.    
  756. #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  757.     BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
  758.     {
  759.       this->move_assign(f);
  760.     }
  761. #endif
  762.    
  763.     ~BOOST_FUNCTION_FUNCTION() { clear(); }
  764.  
  765.     result_type operator()(BOOST_FUNCTION_PARMS) const
  766.     {
  767.       if (this->empty())
  768.         mars_boost::throw_exception(bad_function_call());
  769.  
  770.       return get_vtable()->invoker
  771.                (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
  772.     }
  773.  
  774.     // The distinction between when to use BOOST_FUNCTION_FUNCTION and
  775.     // when to use self_type is obnoxious. MSVC cannot handle self_type as
  776.     // the return type of these assignment operators, but Borland C++ cannot
  777.     // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
  778.     // construct.
  779.     template<typename Functor>
  780. #ifndef BOOST_NO_SFINAE
  781.     typename mars_boost::enable_if_c<
  782.                   !(is_integral<Functor>::value),
  783.                BOOST_FUNCTION_FUNCTION&>::type
  784. #else
  785.     BOOST_FUNCTION_FUNCTION&
  786. #endif
  787.     operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
  788.     {
  789.       this->clear();
  790.       BOOST_TRY  {
  791.         this->assign_to(f);
  792.       } BOOST_CATCH (...) {
  793.         vtable = 0;
  794.         BOOST_RETHROW;
  795.       }
  796.       BOOST_CATCH_END
  797.       return *this;
  798.     }
  799.     template<typename Functor,typename Allocator>
  800.     void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
  801.     {
  802.       this->clear();
  803.       BOOST_TRY{
  804.         this->assign_to_a(f,a);
  805.       } BOOST_CATCH (...) {
  806.         vtable = 0;
  807.         BOOST_RETHROW;
  808.       }
  809.       BOOST_CATCH_END
  810.     }
  811.  
  812. #ifndef BOOST_NO_SFINAE
  813.     BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
  814.     {
  815.       this->clear();
  816.       return *this;
  817.     }
  818. #else
  819.     BOOST_FUNCTION_FUNCTION& operator=(int zero)
  820.     {
  821.       BOOST_ASSERT(zero == 0);
  822.       this->clear();
  823.       return *this;
  824.     }
  825. #endif
  826.  
  827.     // Assignment from another BOOST_FUNCTION_FUNCTION
  828.     BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
  829.     {
  830.       if (&f == this)
  831.         return *this;
  832.  
  833.       this->clear();
  834.       BOOST_TRY {
  835.         this->assign_to_own(f);
  836.       } BOOST_CATCH (...) {
  837.         vtable = 0;
  838.         BOOST_RETHROW;
  839.       }
  840.       BOOST_CATCH_END
  841.       return *this;
  842.     }
  843.    
  844. #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  845.     // Move assignment from another BOOST_FUNCTION_FUNCTION
  846.     BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
  847.     {
  848.      
  849.       if (&f == this)
  850.         return *this;
  851.  
  852.       this->clear();
  853.       BOOST_TRY {
  854.         this->move_assign(f);
  855.       } BOOST_CATCH (...) {
  856.         vtable = 0;
  857.         BOOST_RETHROW;
  858.       }
  859.       BOOST_CATCH_END
  860.       return *this;
  861.     }
  862. #endif
  863.  
  864.     void swap(BOOST_FUNCTION_FUNCTION& other)
  865.     {
  866.       if (&other == this)
  867.         return;
  868.  
  869.       BOOST_FUNCTION_FUNCTION tmp;
  870.       tmp.move_assign(*this);
  871.       this->move_assign(other);
  872.       other.move_assign(tmp);
  873.     }
  874.  
  875.     // Clear out a target, if there is one
  876.     void clear()
  877.     {
  878.       if (vtable) {
  879.         if (!this->has_trivial_copy_and_destroy())
  880.           get_vtable()->clear(this->functor);
  881.         vtable = 0;
  882.       }
  883.     }
  884.  
  885. #if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
  886.     // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
  887.     operator bool () const { return !this->empty(); }
  888. #else
  889.   private:
  890.     struct dummy {
  891.       void nonnull() {}
  892.     };
  893.  
  894.     typedef void (dummy::*safe_bool)();
  895.  
  896.   public:
  897.     operator safe_bool () const
  898.       { return (this->empty())? 0 : &dummy::nonnull; }
  899.  
  900.     bool operator!() const
  901.       { return this->empty(); }
  902. #endif
  903.  
  904.   private:
  905.     void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
  906.     {
  907.       if (!f.empty()) {
  908.         this->vtable = f.vtable;
  909.         if (this->has_trivial_copy_and_destroy())
  910.           this->functor = f.functor;
  911.         else
  912.           get_vtable()->base.manager(f.functor, this->functor,
  913.                                      mars_boost::detail::function::clone_functor_tag);
  914.       }
  915.     }
  916.  
  917.     template<typename Functor>
  918.     void assign_to(Functor f)
  919.     {
  920.       using mars_boost::detail::function::vtable_base;
  921.  
  922.       typedef typename mars_boost::detail::function::get_function_tag<Functor>::type tag;
  923.       typedef mars_boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
  924.       typedef typename get_invoker::
  925.                          template apply<Functor, R BOOST_FUNCTION_COMMA
  926.                         BOOST_FUNCTION_TEMPLATE_ARGS>
  927.         handler_type;
  928.      
  929.       typedef typename handler_type::invoker_type invoker_type;
  930.       typedef typename handler_type::manager_type manager_type;
  931.  
  932.       // Note: it is extremely important that this initialization use
  933.       // static initialization. Otherwise, we will have a race
  934.       // condition here in multi-threaded code. See
  935.       // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
  936.       static const vtable_type stored_vtable =
  937.         { { &manager_type::manage }, &invoker_type::invoke };
  938.  
  939.       if (stored_vtable.assign_to(f, functor)) {
  940.         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
  941.         // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
  942.         if (mars_boost::has_trivial_copy_constructor<Functor>::value &&
  943.             mars_boost::has_trivial_destructor<Functor>::value &&
  944.             mars_boost::detail::function::function_allows_small_object_optimization<Functor>::value)
  945.           value |= static_cast<std::size_t>(0x01);
  946.         vtable = reinterpret_cast<mars_boost::detail::function::vtable_base *>(value);
  947.       } else
  948.         vtable = 0;
  949.     }
  950.  
  951.     template<typename Functor,typename Allocator>
  952.     void assign_to_a(Functor f,Allocator a)
  953.     {
  954.       using mars_boost::detail::function::vtable_base;
  955.  
  956.       typedef typename mars_boost::detail::function::get_function_tag<Functor>::type tag;
  957.       typedef mars_boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
  958.       typedef typename get_invoker::
  959.                          template apply_a<Functor, R BOOST_FUNCTION_COMMA
  960.                          BOOST_FUNCTION_TEMPLATE_ARGS,
  961.                          Allocator>
  962.         handler_type;
  963.      
  964.       typedef typename handler_type::invoker_type invoker_type;
  965.       typedef typename handler_type::manager_type manager_type;
  966.  
  967.       // Note: it is extremely important that this initialization use
  968.       // static initialization. Otherwise, we will have a race
  969.       // condition here in multi-threaded code. See
  970.       // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
  971.       static const vtable_type stored_vtable =
  972.         { { &manager_type::manage }, &invoker_type::invoke };
  973.  
  974.       if (stored_vtable.assign_to_a(f, functor, a)) {
  975.         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
  976.         // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
  977.         if (mars_boost::has_trivial_copy_constructor<Functor>::value &&
  978.             mars_boost::has_trivial_destructor<Functor>::value &&
  979.             mars_boost::detail::function::function_allows_small_object_optimization<Functor>::value)
  980.           value |= static_cast<std::size_t>(0x01);
  981.         vtable = reinterpret_cast<mars_boost::detail::function::vtable_base *>(value);
  982.       } else
  983.         vtable = 0;
  984.     }
  985.  
  986.     // Moves the value from the specified argument to *this. If the argument
  987.     // has its function object allocated on the heap, move_assign will pass
  988.     // its buffer to *this, and set the argument's buffer pointer to NULL.
  989.     void move_assign(BOOST_FUNCTION_FUNCTION& f)
  990.     {
  991.       if (&f == this)
  992.         return;
  993.  
  994.       BOOST_TRY {
  995.         if (!f.empty()) {
  996.           this->vtable = f.vtable;
  997.           if (this->has_trivial_copy_and_destroy())
  998.             this->functor = f.functor;
  999.           else
  1000.             get_vtable()->base.manager(f.functor, this->functor,
  1001.                                      mars_boost::detail::function::move_functor_tag);
  1002.           f.vtable = 0;
  1003.         } else {
  1004.           clear();
  1005.         }
  1006.       } BOOST_CATCH (...) {
  1007.         vtable = 0;
  1008.         BOOST_RETHROW;
  1009.       }
  1010.       BOOST_CATCH_END
  1011.     }
  1012.   };
  1013.  
  1014.   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  1015.   inline void swap(BOOST_FUNCTION_FUNCTION<
  1016.                      R BOOST_FUNCTION_COMMA
  1017.                      BOOST_FUNCTION_TEMPLATE_ARGS
  1018.                    >& f1,
  1019.                    BOOST_FUNCTION_FUNCTION<
  1020.                      R BOOST_FUNCTION_COMMA
  1021.                      BOOST_FUNCTION_TEMPLATE_ARGS
  1022.                    >& f2)
  1023.   {
  1024.     f1.swap(f2);
  1025.   }
  1026.  
  1027. // Poison comparisons between mars_boost::function objects of the same type.
  1028. template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  1029.   void operator==(const BOOST_FUNCTION_FUNCTION<
  1030.                           R BOOST_FUNCTION_COMMA
  1031.                           BOOST_FUNCTION_TEMPLATE_ARGS>&,
  1032.                   const BOOST_FUNCTION_FUNCTION<
  1033.                           R BOOST_FUNCTION_COMMA
  1034.                           BOOST_FUNCTION_TEMPLATE_ARGS>&);
  1035. template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  1036.   void operator!=(const BOOST_FUNCTION_FUNCTION<
  1037.                           R BOOST_FUNCTION_COMMA
  1038.                           BOOST_FUNCTION_TEMPLATE_ARGS>&,
  1039.                   const BOOST_FUNCTION_FUNCTION<
  1040.                           R BOOST_FUNCTION_COMMA
  1041.                           BOOST_FUNCTION_TEMPLATE_ARGS>& );
  1042.  
  1043. #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
  1044.  
  1045. #if BOOST_FUNCTION_NUM_ARGS == 0
  1046. #define BOOST_FUNCTION_PARTIAL_SPEC R (void)
  1047. #else
  1048. #define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
  1049. #endif
  1050.  
  1051. template<typename R BOOST_FUNCTION_COMMA
  1052.          BOOST_FUNCTION_TEMPLATE_PARMS>
  1053. class function<BOOST_FUNCTION_PARTIAL_SPEC>
  1054.   : public BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
  1055. {
  1056.   typedef BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
  1057.   typedef function self_type;
  1058.  
  1059.   struct clear_type {};
  1060.  
  1061. public:
  1062.  
  1063.   function() : base_type() {}
  1064.  
  1065.   template<typename Functor>
  1066.   function(Functor f
  1067. #ifndef BOOST_NO_SFINAE
  1068.            ,typename mars_boost::enable_if_c<
  1069.                           !(is_integral<Functor>::value),
  1070.                        int>::type = 0
  1071. #endif
  1072.            ) :
  1073.     base_type(f)
  1074.   {
  1075.   }
  1076.   template<typename Functor,typename Allocator>
  1077.   function(Functor f, Allocator a
  1078. #ifndef BOOST_NO_SFINAE
  1079.            ,typename mars_boost::enable_if_c<
  1080.                            !(is_integral<Functor>::value),
  1081.                        int>::type = 0
  1082. #endif
  1083.            ) :
  1084.     base_type(f,a)
  1085.   {
  1086.   }
  1087.  
  1088. #ifndef BOOST_NO_SFINAE
  1089.   function(clear_type*) : base_type() {}
  1090. #endif
  1091.  
  1092.   function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
  1093.  
  1094.   function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
  1095.  
  1096. #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  1097.   // Move constructors
  1098.   function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  1099.   function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
  1100. #endif
  1101.  
  1102.   self_type& operator=(const self_type& f)
  1103.   {
  1104.     self_type(f).swap(*this);
  1105.     return *this;
  1106.   }
  1107.  
  1108. #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  1109.   self_type& operator=(self_type&& f)
  1110.   {
  1111.     self_type(static_cast<self_type&&>(f)).swap(*this);
  1112.     return *this;
  1113.   }
  1114. #endif  
  1115.  
  1116.   template<typename Functor>
  1117. #ifndef BOOST_NO_SFINAE
  1118.   typename mars_boost::enable_if_c<
  1119.                          !(is_integral<Functor>::value),
  1120.                       self_type&>::type
  1121. #else
  1122.   self_type&
  1123. #endif
  1124.   operator=(Functor f)
  1125.   {
  1126.     self_type(f).swap(*this);
  1127.     return *this;
  1128.   }
  1129.  
  1130. #ifndef BOOST_NO_SFINAE
  1131.   self_type& operator=(clear_type*)
  1132.   {
  1133.     this->clear();
  1134.     return *this;
  1135.   }
  1136. #endif
  1137.  
  1138.   self_type& operator=(const base_type& f)
  1139.   {
  1140.     self_type(f).swap(*this);
  1141.     return *this;
  1142.   }
  1143.  
  1144. #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
  1145.   self_type& operator=(base_type&& f)
  1146.   {
  1147.     self_type(static_cast<base_type&&>(f)).swap(*this);
  1148.     return *this;
  1149.   }
  1150. #endif
  1151. };
  1152.  
  1153. #undef BOOST_FUNCTION_PARTIAL_SPEC
  1154. #endif // have partial specialization
  1155.  
  1156. } // end namespace mars_boost
  1157.  
  1158. // Cleanup after ourselves...
  1159. #undef BOOST_FUNCTION_VTABLE
  1160. #undef BOOST_FUNCTION_COMMA
  1161. #undef BOOST_FUNCTION_FUNCTION
  1162. #undef BOOST_FUNCTION_FUNCTION_INVOKER
  1163. #undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
  1164. #undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
  1165. #undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
  1166. #undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
  1167. #undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
  1168. #undef BOOST_FUNCTION_MEMBER_INVOKER
  1169. #undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
  1170. #undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
  1171. #undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
  1172. #undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
  1173. #undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
  1174. #undef BOOST_FUNCTION_GET_INVOKER
  1175. #undef BOOST_FUNCTION_TEMPLATE_PARMS
  1176. #undef BOOST_FUNCTION_TEMPLATE_ARGS
  1177. #undef BOOST_FUNCTION_PARMS
  1178. #undef BOOST_FUNCTION_PARM
  1179. #ifdef BOOST_FUNCTION_ARG
  1180. #   undef BOOST_FUNCTION_ARG
  1181. #endif
  1182. #undef BOOST_FUNCTION_ARGS
  1183. #undef BOOST_FUNCTION_ARG_TYPE
  1184. #undef BOOST_FUNCTION_ARG_TYPES
  1185. #undef BOOST_FUNCTION_VOID_RETURN_TYPE
  1186. #undef BOOST_FUNCTION_RETURN
  1187.  
  1188. #if defined(BOOST_MSVC)
  1189. #   pragma warning( pop )
  1190. #endif      
  1191.  
downloadfunction_template.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top