39 #ifndef CGU_CALLBACK_H 
   40 #define CGU_CALLBACK_H 
  536 #include <functional>   
  540 #include <type_traits>  
  649 template <
class... FreeArgs>
 
  689 #ifdef CGU_USE_GLIB_MEMORY_SLICES_NO_COMPAT 
  772   return std::unique_ptr<
const CallbackArg<T...>>(cb);
 
  791 template <
class... T>
 
  793   return (f1.cb_s.get() == f2.cb_s.get());
 
  801 template <
class... T>
 
  819 template <
class... T>
 
  821   return std::less<
const CallbackArg<T...>*>()(f1.cb_s.get(), f2.cb_s.get());
 
  829 template <
class... T>
 
  831   return (f1.cb_s.get() == f2.cb_s.get());
 
  839 template <
class... T>
 
  852 template <
class... T>
 
  854   return std::less<
const CallbackArg<T...>*>()(f1.cb_s.get(), f2.cb_s.get());
 
  863 #ifndef DOXYGEN_PARSING 
  868 template <
class... T>
 
  869 struct hash<
Cgu::Callback::FunctorArg<T...>> {
 
  870   typedef std::size_t result_type;
 
  872   result_type operator()(
const argument_type& f)
 const {
 
  879 template <
class... T>
 
  880 struct hash<
Cgu::Callback::SafeFunctorArg<T...>> {
 
  881   typedef std::size_t result_type;
 
  883   result_type operator()(
const argument_type& f)
 const {
 
  892 #endif // DOXYGEN_PARSING 
  955 template <
class... FreeArgs>
 
  957   SharedPtr<
const CallbackArg<FreeArgs...>> cb_s;
 
  980     if (cb_s.get()) cb_s->dispatch(args...);
 
 1079 template <
class... FreeArgs>
 
 1080 class SafeFunctorArg {
 
 1095     if (cb_s.get()) cb_s->dispatch(args...);
 
 1211 template<
class... T>
 
 1251 template<
class... T>
 
 1259 template <
class Lambda, 
class... FreeArgs>
 
 1269 #if defined(DOXYGEN_PARSING) || defined(CGU_USE_TUPLE) 
 1272 template <
class T, 
class MemFunc, 
class Tuple, 
class... FreeArgs>
 
 1282   template <
class... Args>
 
 1284     obj(&obj_), func(func_), tuple(std::forward<Args>(args)...) {}
 
 1291 template <
class T, 
class MemFunc, 
class... FreeArgs>
 
 1297     (obj->*func)(free_args...);
 
 1304 template <
class Func, 
class Tuple, 
class... FreeArgs>
 
 1313   template <
class... Args>
 
 1315     func(func_), tuple(std::forward<Args>(args)...) {}
 
 1333 template <
class T, 
class... FreeArgs>
 
 1335                    void (T::*func)(FreeArgs...)) {
 
 1351 template <
class T, 
class... FreeArgs>
 
 1353                    void (T::*func)(FreeArgs...)) {
 
 1368 template <
class T, 
class BoundArg, 
class... FreeArgs>
 
 1370                    void (T::*func)(BoundArg, FreeArgs...),
 
 1372   typedef std::tuple<BoundArg> Tuple;
 
 1394 template <
class T, 
class BoundArg, 
class Arg, 
class... FreeArgs>
 
 1396                    void (T::*func)(BoundArg, FreeArgs...),
 
 1398   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg>::type>::type> Tuple;
 
 1400     {t, func, std::forward<Arg>(arg)};
 
 1414 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 1416                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 1419   typedef std::tuple<BoundArg1, BoundArg2> Tuple;
 
 1421     {t, func, arg1, arg2};
 
 1441 template <
class T, 
class BoundArg1, 
class BoundArg2,
 
 1442           class Arg1, 
class Arg2, 
class... FreeArgs>
 
 1444                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 1447   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1448              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type> Tuple;
 
 1450     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2)};
 
 1464 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 1466                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 1470   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3> Tuple;
 
 1472     {t, func, arg1, arg2, arg3};
 
 1492 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 1493           class Arg1, 
class Arg2, 
class Arg3, 
class... FreeArgs>
 
 1495                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 1499   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1500              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 1501              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type> Tuple;
 
 1503     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3)};
 
 1517 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 1518           class BoundArg4, 
class... FreeArgs>
 
 1520                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1521                            BoundArg4, FreeArgs...),
 
 1526   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4> Tuple;
 
 1528     {t, func, arg1, arg2, arg3, arg4};
 
 1548 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 1549           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class... FreeArgs>
 
 1551                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1552                            BoundArg4, FreeArgs...),
 
 1557   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1558              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 1559              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 1560              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type> Tuple;
 
 1562     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2),
 
 1563      std::forward<Arg3>(arg3), std::forward<Arg4>(arg4)};
 
 1577 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 1578           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 1580                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1581                            BoundArg4, BoundArg5, FreeArgs...),
 
 1587   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4, BoundArg5> Tuple;
 
 1589     {t, func, arg1, arg2, arg3, arg4, arg5};
 
 1609 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4, 
class BoundArg5,
 
 1610           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class... FreeArgs>
 
 1612                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1613                            BoundArg4, BoundArg5, FreeArgs...),
 
 1619   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1620              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 1621              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 1622              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 1623              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type> Tuple;
 
 1625     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 1626      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5)};
 
 1647 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 1648           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class... FreeArgs>
 
 1650                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1651                            BoundArg4, BoundArg5, BoundArg6,
 
 1659   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 1660                      BoundArg5, BoundArg6> Tuple;
 
 1662     {t, func, arg1, arg2, arg3, arg4, arg5, arg6};
 
 1687 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 1688           class BoundArg5, 
class BoundArg6, 
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4,
 
 1689           class Arg5, 
class Arg6, 
class... FreeArgs>
 
 1691                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1692                            BoundArg4, BoundArg5, BoundArg6,
 
 1700   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1701              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 1702              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 1703              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 1704              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 1705              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type> Tuple;
 
 1707     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 1708      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6)};
 
 1729 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 1730           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 1733                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1734                            BoundArg4, BoundArg5, BoundArg6,
 
 1735                            BoundArg7, FreeArgs...),
 
 1743   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 1744                      BoundArg5, BoundArg6, BoundArg7> Tuple;
 
 1746     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7};
 
 1771 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 1772           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class Arg1, 
class Arg2,
 
 1773           class Arg3, 
class Arg4, 
class Arg5, 
class Arg6, 
class Arg7, 
class... FreeArgs>
 
 1775                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1776                            BoundArg4, BoundArg5, BoundArg6,
 
 1777                            BoundArg7, FreeArgs...),
 
 1785   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1786              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 1787              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 1788              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 1789              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 1790              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 1791              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type> Tuple;
 
 1793     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 1794      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 1795      std::forward<Arg7>(arg7)};
 
 1816 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 1817           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 1818           class BoundArg8, 
class... FreeArgs>
 
 1820                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1821                            BoundArg4, BoundArg5, BoundArg6,
 
 1822                            BoundArg7, BoundArg8, FreeArgs...),
 
 1831   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 1832                      BoundArg5, BoundArg6, BoundArg7, BoundArg8> Tuple;
 
 1834     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8};
 
 1859 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 1860           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8, 
class Arg1,
 
 1861       class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class Arg6, 
class Arg7, 
class Arg8,
 
 1864                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1865                            BoundArg4, BoundArg5, BoundArg6,
 
 1866                            BoundArg7, BoundArg8, FreeArgs...),
 
 1875   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1876              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 1877              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 1878              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 1879              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 1880              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 1881              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 1882              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type> Tuple;
 
 1884     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 1885      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 1886      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8)};
 
 1907 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 1908           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 1909           class BoundArg8, 
class BoundArg9, 
class... FreeArgs>
 
 1911                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1912                            BoundArg4, BoundArg5, BoundArg6,
 
 1913                            BoundArg7, BoundArg8, BoundArg9,
 
 1924   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 1925                      BoundArg5, BoundArg6, BoundArg7, BoundArg8,
 
 1928     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9};
 
 1953 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 1954           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8, 
class BoundArg9,
 
 1955       class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class Arg6, 
class Arg7,
 
 1956       class Arg8, 
class Arg9, 
class... FreeArgs>
 
 1958                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 1959                            BoundArg4, BoundArg5, BoundArg6,
 
 1960                            BoundArg7, BoundArg8, BoundArg9,
 
 1971   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 1972              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 1973              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 1974              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 1975              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 1976              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 1977              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 1978              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type,
 
 1979              typename std::remove_const<typename std::remove_reference<BoundArg9>::type>::type> Tuple;
 
 1981     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 1982      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 1983      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8), std::forward<Arg9>(arg9)};
 
 2004 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2005           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 2006           class BoundArg8, 
class BoundArg9, 
class BoundArg10, 
class... FreeArgs>
 
 2008                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2009                            BoundArg4, BoundArg5, BoundArg6,
 
 2010                            BoundArg7, BoundArg8, BoundArg9,
 
 2011                            BoundArg10, FreeArgs...),
 
 2022   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 2023                      BoundArg5, BoundArg6, BoundArg7, BoundArg8,
 
 2024              BoundArg9, BoundArg10> Tuple;
 
 2026     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10};
 
 2051 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 2052           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8, 
class BoundArg9,
 
 2053       class BoundArg10, 
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class Arg6,
 
 2054       class Arg7, 
class Arg8, 
class Arg9, 
class Arg10, 
class... FreeArgs>
 
 2056                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2057                            BoundArg4, BoundArg5, BoundArg6,
 
 2058                            BoundArg7, BoundArg8, BoundArg9,
 
 2059                            BoundArg10, FreeArgs...),
 
 2070   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2071              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2072              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2073              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 2074              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 2075              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 2076              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 2077              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type,
 
 2078              typename std::remove_const<typename std::remove_reference<BoundArg9>::type>::type,
 
 2079              typename std::remove_const<typename std::remove_reference<BoundArg10>::type>::type> Tuple;
 
 2081     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 2082      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 2083      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8), std::forward<Arg9>(arg9),
 
 2084      std::forward<Arg10>(arg10)};
 
 2098 template <
class T, 
class... FreeArgs>
 
 2100                    void (T::*func)(FreeArgs...) 
const) {
 
 2101   return new Callback_memfun<
const T, decltype(func), FreeArgs...>{t, func};
 
 2116 template <
class T, 
class... FreeArgs>
 
 2118                    void (T::*func)(FreeArgs...) 
const) {
 
 2119   return new Callback_memfun<
const T, decltype(func), FreeArgs...>{t, func};
 
 2133 template <
class T, 
class BoundArg, 
class... FreeArgs>
 
 2135                    void (T::*func)(BoundArg, FreeArgs...) 
const,
 
 2137   typedef std::tuple<BoundArg> Tuple;
 
 2159 template <
class T, 
class BoundArg, 
class Arg, 
class... FreeArgs>
 
 2161                    void (T::*func)(BoundArg, FreeArgs...) 
const,
 
 2163   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg>::type>::type> Tuple;
 
 2165     {t, func, std::forward<Arg>(arg)};
 
 2179 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 2181                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...) 
const,
 
 2184   typedef std::tuple<BoundArg1, BoundArg2> Tuple;
 
 2186     {t, func, arg1, arg2};
 
 2206 template <
class T, 
class BoundArg1, 
class BoundArg2,
 
 2207           class Arg1, 
class Arg2, 
class... FreeArgs>
 
 2209                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...) 
const,
 
 2212   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2213              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type> Tuple;
 
 2215     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2)};
 
 2229 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 2231                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...) 
const,
 
 2235   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3> Tuple;
 
 2237     {t, func, arg1, arg2, arg3};
 
 2257 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2258           class Arg1, 
class Arg2, 
class Arg3, 
class... FreeArgs>
 
 2260                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...) 
const,
 
 2264   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2265              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2266              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type> Tuple;
 
 2268     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3)};
 
 2282 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2283           class BoundArg4, 
class... FreeArgs>
 
 2285                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2286                            BoundArg4, FreeArgs...) 
const,
 
 2291   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4> Tuple;
 
 2293     {t, func, arg1, arg2, arg3, arg4};
 
 2313 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 2314           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class... FreeArgs>
 
 2316                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2317                            BoundArg4, FreeArgs...) 
const,
 
 2322   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2323              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2324              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2325              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type> Tuple;
 
 2327     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2),
 
 2328      std::forward<Arg3>(arg3), std::forward<Arg4>(arg4)};
 
 2342 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2343           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 2345                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2346                            BoundArg4, BoundArg5, FreeArgs...) 
const,
 
 2352   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4, BoundArg5> Tuple;
 
 2354     {t, func, arg1, arg2, arg3, arg4, arg5};
 
 2374 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4, 
class BoundArg5,
 
 2375           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class... FreeArgs>
 
 2377                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2378                            BoundArg4, BoundArg5, FreeArgs...) 
const,
 
 2384   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2385              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2386              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2387              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 2388              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type> Tuple;
 
 2390     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 2391      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5)};
 
 2412 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2413           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class... FreeArgs>
 
 2415                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2416                            BoundArg4, BoundArg5, BoundArg6,
 
 2424   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 2425                      BoundArg5, BoundArg6> Tuple;
 
 2427     {t, func, arg1, arg2, arg3, arg4, arg5, arg6};
 
 2452 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 2453           class BoundArg5, 
class BoundArg6, 
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4,
 
 2454           class Arg5, 
class Arg6, 
class... FreeArgs>
 
 2456                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2457                            BoundArg4, BoundArg5, BoundArg6,
 
 2465   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2466              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2467              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2468              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 2469              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 2470              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type> Tuple;
 
 2472     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 2473      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6)};
 
 2494 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2495           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 2498                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2499                            BoundArg4, BoundArg5, BoundArg6,
 
 2500                            BoundArg7, FreeArgs...) 
const,
 
 2508   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 2509                      BoundArg5, BoundArg6, BoundArg7> Tuple;
 
 2511     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7};
 
 2536 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 2537           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class Arg1, 
class Arg2,
 
 2538           class Arg3, 
class Arg4, 
class Arg5, 
class Arg6, 
class Arg7, 
class... FreeArgs>
 
 2540                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2541                            BoundArg4, BoundArg5, BoundArg6,
 
 2542                            BoundArg7, FreeArgs...) 
const,
 
 2550   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2551              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2552              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2553              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 2554              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 2555              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 2556              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type> Tuple;
 
 2558     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 2559      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 2560      std::forward<Arg7>(arg7)};
 
 2581 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2582           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 2583           class BoundArg8, 
class... FreeArgs>
 
 2585                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2586                            BoundArg4, BoundArg5, BoundArg6,
 
 2587                            BoundArg7, BoundArg8, FreeArgs...) 
const,
 
 2596   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 2597                      BoundArg5, BoundArg6, BoundArg7, BoundArg8> Tuple;
 
 2599     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8};
 
 2624 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 2625           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8, 
class Arg1,
 
 2626       class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class Arg6, 
class Arg7, 
class Arg8,
 
 2629                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2630                            BoundArg4, BoundArg5, BoundArg6,
 
 2631                            BoundArg7, BoundArg8, FreeArgs...) 
const,
 
 2640   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2641              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2642              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2643              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 2644              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 2645              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 2646              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 2647              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type> Tuple;
 
 2649     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 2650      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 2651      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8)};
 
 2672 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2673           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 2674           class BoundArg8, 
class BoundArg9, 
class... FreeArgs>
 
 2676                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2677                            BoundArg4, BoundArg5, BoundArg6,
 
 2678                            BoundArg7, BoundArg8, BoundArg9,
 
 2689   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 2690                      BoundArg5, BoundArg6, BoundArg7, BoundArg8,
 
 2693     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9};
 
 2718 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 2719           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8, 
class BoundArg9,
 
 2720       class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class Arg6, 
class Arg7,
 
 2721       class Arg8, 
class Arg9, 
class... FreeArgs>
 
 2723                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2724                            BoundArg4, BoundArg5, BoundArg6,
 
 2725                            BoundArg7, BoundArg8, BoundArg9,
 
 2736   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2737              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2738              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2739              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 2740              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 2741              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 2742              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 2743              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type,
 
 2744              typename std::remove_const<typename std::remove_reference<BoundArg9>::type>::type> Tuple;
 
 2746     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 2747      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 2748      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8), std::forward<Arg9>(arg9)};
 
 2769 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 2770           class BoundArg4, 
class BoundArg5, 
class BoundArg6, 
class BoundArg7,
 
 2771           class BoundArg8, 
class BoundArg9, 
class BoundArg10, 
class... FreeArgs>
 
 2773                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2774                            BoundArg4, BoundArg5, BoundArg6,
 
 2775                            BoundArg7, BoundArg8, BoundArg9,
 
 2776                            BoundArg10, FreeArgs...) 
const,
 
 2787   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 2788                      BoundArg5, BoundArg6, BoundArg7, BoundArg8,
 
 2789              BoundArg9, BoundArg10> Tuple;
 
 2791     {t, func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10};
 
 2816 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 2817           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8, 
class BoundArg9,
 
 2818       class BoundArg10, 
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class Arg6,
 
 2819       class Arg7, 
class Arg8, 
class Arg9, 
class Arg10, 
class... FreeArgs>
 
 2821                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 2822                            BoundArg4, BoundArg5, BoundArg6,
 
 2823                            BoundArg7, BoundArg8, BoundArg9,
 
 2824                            BoundArg10, FreeArgs...) 
const,
 
 2835   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2836              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 2837              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 2838              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 2839              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 2840              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 2841              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 2842              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type,
 
 2843              typename std::remove_const<typename std::remove_reference<BoundArg9>::type>::type,
 
 2844              typename std::remove_const<typename std::remove_reference<BoundArg10>::type>::type> Tuple;
 
 2846     {t, func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 2847      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 2848      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8), std::forward<Arg9>(arg9),
 
 2849      std::forward<Arg10>(arg10)};
 
 2863 template <
class... FreeArgs>
 
 2880 template <
class... FreeArgs>
 
 2896 template <
class BoundArg, 
class... FreeArgs>
 
 2899   typedef std::tuple<BoundArg> Tuple;
 
 2921 template <
class BoundArg, 
class Arg, 
class... FreeArgs>
 
 2924   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg>::type>::type> Tuple;
 
 2926     {func, std::forward<Arg>(arg)};
 
 2940 template <
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 2944   typedef std::tuple<BoundArg1, BoundArg2> Tuple;
 
 2966 template <
class BoundArg1, 
class BoundArg2, 
class Arg1, 
class Arg2, 
class... FreeArgs>
 
 2970   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 2971              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type> Tuple;
 
 2973     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2)};
 
 2987 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 2988 CallbackArg<FreeArgs...>* 
make(
void (*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 2992   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3> Tuple;
 
 2994     {func, arg1, arg2, arg3};
 
 3014 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 3015           class Arg1, 
class Arg2, 
class Arg3, 
class... FreeArgs>
 
 3020   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3021              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3022              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type> Tuple;
 
 3024     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3)};
 
 3038 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 3039           class BoundArg4, 
class... FreeArgs>
 
 3041                         BoundArg4, FreeArgs...),
 
 3046   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4> Tuple;
 
 3048     {func, arg1, arg2, arg3, arg4};
 
 3068 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3069           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class... FreeArgs>
 
 3071                         BoundArg4, FreeArgs...),
 
 3076   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3077              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3078              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 3079              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type> Tuple;
 
 3081     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2),
 
 3082      std::forward<Arg3>(arg3), std::forward<Arg4>(arg4)};
 
 3096 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 3097           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 3099                         BoundArg4, BoundArg5, FreeArgs...),
 
 3105   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4, BoundArg5> Tuple;
 
 3107     {func, arg1, arg2, arg3, arg4, arg5};
 
 3127 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4, 
class BoundArg5,
 
 3128           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class... FreeArgs>
 
 3130                         BoundArg4, BoundArg5, FreeArgs...),
 
 3136   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3137              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3138              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 3139              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 3140              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type> Tuple;
 
 3142     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 3143      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5)};
 
 3164 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3165           class BoundArg5, 
class BoundArg6, 
class... FreeArgs>
 
 3167                         BoundArg4, BoundArg5, BoundArg6,
 
 3175   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 3176                      BoundArg5, BoundArg6> Tuple;
 
 3178     {func, arg1, arg2, arg3, arg4, arg5, arg6};
 
 3203 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4, 
class BoundArg5,
 
 3204           class BoundArg6, 
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5,
 
 3205           class Arg6, 
class... FreeArgs>
 
 3207                         BoundArg4, BoundArg5, BoundArg6,
 
 3215   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3216              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3217              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 3218              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 3219              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 3220              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type> Tuple;
 
 3222     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 3223      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6)};
 
 3244 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3245           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class... FreeArgs>
 
 3247                         BoundArg4, BoundArg5, BoundArg6,
 
 3248                         BoundArg7, FreeArgs...),
 
 3256   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 3257                      BoundArg5, BoundArg6, BoundArg7> Tuple;
 
 3259     {func, arg1, arg2, arg3, arg4, arg5, arg6, arg7};
 
 3284 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3285           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class Arg1, 
class Arg2,
 
 3286           class Arg3, 
class Arg4, 
class Arg5, 
class Arg6, 
class Arg7, 
class... FreeArgs>
 
 3288                         BoundArg4, BoundArg5, BoundArg6,
 
 3289                         BoundArg7, FreeArgs...),
 
 3297   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3298              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3299              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 3300              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 3301              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 3302              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 3303              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type> Tuple;
 
 3305     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 3306      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 3307      std::forward<Arg7>(arg7)};
 
 3328 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3329           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8,
 
 3332                         BoundArg4, BoundArg5, BoundArg6,
 
 3333                         BoundArg7, BoundArg8, FreeArgs...),
 
 3342   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 3343                      BoundArg5, BoundArg6, BoundArg7, BoundArg8> Tuple;
 
 3345     {func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8};
 
 3370 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3371           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8,
 
 3372       class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class Arg6,
 
 3373       class Arg7, 
class Arg8, 
class... FreeArgs>
 
 3375                         BoundArg4, BoundArg5, BoundArg6,
 
 3376                         BoundArg7, BoundArg8, FreeArgs...),
 
 3385   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3386              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3387              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 3388              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 3389              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 3390              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 3391              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 3392              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type> Tuple;
 
 3394     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 3395      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 3396      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8)};
 
 3417 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3418           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8,
 
 3419           class BoundArg9, 
class... FreeArgs>
 
 3421                         BoundArg4, BoundArg5, BoundArg6,
 
 3422                         BoundArg7, BoundArg8, BoundArg9,
 
 3433   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 3434                      BoundArg5, BoundArg6, BoundArg7, BoundArg8,
 
 3437     {func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9};
 
 3462 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3463           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8,
 
 3464       class BoundArg9, 
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4,
 
 3465       class Arg5, 
class Arg6, 
class Arg7, 
class Arg8, 
class Arg9,
 
 3468                         BoundArg4, BoundArg5, BoundArg6,
 
 3469                         BoundArg7, BoundArg8, BoundArg9,
 
 3480   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3481              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3482              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 3483              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 3484              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 3485              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 3486              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 3487              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type,
 
 3488              typename std::remove_const<typename std::remove_reference<BoundArg9>::type>::type> Tuple;
 
 3490     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 3491      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 3492      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8), std::forward<Arg9>(arg9)};
 
 3513 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3514           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8,
 
 3515           class BoundArg9, 
class BoundArg10, 
class... FreeArgs>
 
 3517                         BoundArg4, BoundArg5, BoundArg6,
 
 3518                         BoundArg7, BoundArg8, BoundArg9,
 
 3519                         BoundArg10, FreeArgs...),
 
 3530   typedef std::tuple<BoundArg1, BoundArg2, BoundArg3, BoundArg4,
 
 3531                      BoundArg5, BoundArg6, BoundArg7, BoundArg8,
 
 3532              BoundArg9, BoundArg10> Tuple;
 
 3534     {func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10};
 
 3559 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 3560           class BoundArg5, 
class BoundArg6, 
class BoundArg7, 
class BoundArg8,
 
 3561       class BoundArg9, 
class BoundArg10, 
class Arg1, 
class Arg2, 
class Arg3,
 
 3562       class Arg4, 
class Arg5, 
class Arg6, 
class Arg7, 
class Arg8, 
class Arg9,
 
 3563       class Arg10, 
class... FreeArgs>
 
 3565                         BoundArg4, BoundArg5, BoundArg6,
 
 3566                         BoundArg7, BoundArg8, BoundArg9,
 
 3567                         BoundArg10, FreeArgs...),
 
 3578   typedef std::tuple<typename std::remove_const<typename std::remove_reference<BoundArg1>::type>::type,
 
 3579              typename std::remove_const<typename std::remove_reference<BoundArg2>::type>::type,
 
 3580              typename std::remove_const<typename std::remove_reference<BoundArg3>::type>::type,
 
 3581              typename std::remove_const<typename std::remove_reference<BoundArg4>::type>::type,
 
 3582              typename std::remove_const<typename std::remove_reference<BoundArg5>::type>::type,
 
 3583              typename std::remove_const<typename std::remove_reference<BoundArg6>::type>::type,
 
 3584              typename std::remove_const<typename std::remove_reference<BoundArg7>::type>::type,
 
 3585              typename std::remove_const<typename std::remove_reference<BoundArg8>::type>::type,
 
 3586              typename std::remove_const<typename std::remove_reference<BoundArg9>::type>::type,
 
 3587              typename std::remove_const<typename std::remove_reference<BoundArg10>::type>::type> Tuple;
 
 3589     {func, std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3),
 
 3590      std::forward<Arg4>(arg4), std::forward<Arg5>(arg5), std::forward<Arg6>(arg6),
 
 3591      std::forward<Arg7>(arg7), std::forward<Arg8>(arg8), std::forward<Arg9>(arg9),
 
 3592      std::forward<Arg10>(arg10)};
 
 3595 #endif // CGU_USE_TUPLE 
 3611 template <
class... FreeArgs>
 
 3613   typedef std::function<void(FreeArgs...)> LType;
 
 3631 template <
class... FreeArgs>
 
 3633   typedef std::function<void(FreeArgs...)> LType;
 
 3649 template <
class... FreeArgs>
 
 3651   typedef std::function<void(FreeArgs...)> LType;
 
 3669 template <
class... FreeArgs>
 
 3671   typedef std::function<void(FreeArgs...)> LType;
 
 3715 template <
class... FreeArgs, 
class Lambda>
 
 3717   typedef typename std::remove_const<typename std::remove_reference<Lambda>::type>::type LType;
 
 3718   return new Callback_lambda<LType, FreeArgs...>{std::forward<Lambda>(l)};
 
 3733 #ifndef DOXYGEN_PARSING 
 3741 template <
class T, 
class... FreeArgs>
 
 3742 class Callback0: 
public CallbackArg<FreeArgs...> {
 
 3744   typedef void (T::* MemFunc)(FreeArgs...);
 
 3750     (obj->*func)(free_args...);
 
 3752   Callback0(T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
 
 3755 template <
bool unref, 
class T, 
class BoundArg, 
class... FreeArgs>
 
 3756 class Callback1: 
public CallbackArg<FreeArgs...> {
 
 3758   typedef void (T::* MemFunc)(BoundArg, FreeArgs...);
 
 3765     (obj->*func)(arg, free_args...);
 
 3767   template <
class Arg>
 
 3768   Callback1(T& obj_, MemFunc func_,
 
 3769         Arg&& arg_): obj(&obj_), func(func_), arg(std::forward<Arg>(arg_)) {}
 
 3772 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 3773 class Callback2: 
public CallbackArg<FreeArgs...> {
 
 3775   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArgs...);
 
 3783     (obj->*func)(arg1, arg2, free_args...);
 
 3785   template <
class Arg1, 
class Arg2>
 
 3786   Callback2(T& obj_, MemFunc func_,
 
 3788         Arg2&& arg2_): obj(&obj_), func(func_),
 
 3789                            arg1(std::forward<Arg1>(arg1_)),
 
 3790                            arg2(std::forward<Arg2>(arg2_)) {}
 
 3793 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 3794 class Callback3: 
public CallbackArg<FreeArgs...> {
 
 3796   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...);
 
 3805     (obj->*func)(arg1, arg2, arg3, free_args...);
 
 3807   template <
class Arg1, 
class Arg2, 
class Arg3>
 
 3808   Callback3(T& obj_, MemFunc func_,
 
 3812               obj(&obj_), func(func_),
 
 3813           arg1(std::forward<Arg1>(arg1_)),
 
 3814           arg2(std::forward<Arg2>(arg2_)),
 
 3815           arg3(std::forward<Arg3>(arg3_)) {}
 
 3818 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
 
 3819           class BoundArg4, 
class... FreeArgs>
 
 3820 class Callback4: 
public CallbackArg<FreeArgs...> {
 
 3822   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, BoundArg3, BoundArg4, FreeArgs...);
 
 3832     (obj->*func)(arg1, arg2, arg3, arg4, free_args...);
 
 3834   template <
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4>
 
 3835   Callback4(T& obj_, MemFunc func_,
 
 3840               obj(&obj_), func(func_),
 
 3841           arg1(std::forward<Arg1>(arg1_)),
 
 3842           arg2(std::forward<Arg2>(arg2_)),
 
 3843           arg3(std::forward<Arg3>(arg3_)),
 
 3844           arg4(std::forward<Arg4>(arg4_)) {}
 
 3847 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
 
 3848           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 3849 class Callback5: 
public CallbackArg<FreeArgs...> {
 
 3851   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, BoundArg3,
 
 3852                   BoundArg4, BoundArg5, FreeArgs...);
 
 3863     (obj->*func)(arg1, arg2, arg3, arg4, arg5, free_args...);
 
 3865   template <
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5>
 
 3866   Callback5(T& obj_, MemFunc func_,
 
 3872               obj(&obj_), func(func_),
 
 3873           arg1(std::forward<Arg1>(arg1_)),
 
 3874           arg2(std::forward<Arg2>(arg2_)),
 
 3875           arg3(std::forward<Arg3>(arg3_)),
 
 3876           arg4(std::forward<Arg4>(arg4_)),
 
 3877           arg5(std::forward<Arg5>(arg5_)) {}
 
 3880 template <
class T, 
class... FreeArgs>
 
 3881 class Callback0_const: 
public CallbackArg<FreeArgs...> {
 
 3883   typedef void (T::* MemFunc)(FreeArgs...) 
const;
 
 3889     (obj->*func)(free_args...);
 
 3891   Callback0_const(
const T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
 
 3894 template <
bool unref, 
class T, 
class BoundArg, 
class... FreeArgs>
 
 3895 class Callback1_const: 
public CallbackArg<FreeArgs...> {
 
 3897   typedef void (T::* MemFunc)(BoundArg, FreeArgs...) 
const;
 
 3904     (obj->*func)(arg, free_args...);
 
 3906   template <
class Arg>
 
 3907   Callback1_const(
const T& obj_, MemFunc func_,
 
 3908           Arg&& arg_): obj(&obj_), func(func_), arg(std::forward<Arg>(arg_)) {}
 
 3911 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 3912 class Callback2_const: 
public CallbackArg<FreeArgs...> {
 
 3914   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArgs...) 
const;
 
 3922     (obj->*func)(arg1, arg2, free_args...);
 
 3924   template <
class Arg1, 
class Arg2>
 
 3925   Callback2_const(
const T& obj_, MemFunc func_,
 
 3927           Arg2&& arg2_): obj(&obj_), func(func_),
 
 3928                                  arg1(std::forward<Arg1>(arg1_)),
 
 3929                                  arg2(std::forward<Arg2>(arg2_)) {}
 
 3932 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 3933 class Callback3_const: 
public CallbackArg<FreeArgs...> {
 
 3935   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...) 
const;
 
 3944     (obj->*func)(arg1, arg2, arg3, free_args...);
 
 3946   template <
class Arg1, 
class Arg2, 
class Arg3>
 
 3947   Callback3_const(
const T& obj_, MemFunc func_,
 
 3951                     obj(&obj_), func(func_),
 
 3952             arg1(std::forward<Arg1>(arg1_)),
 
 3953             arg2(std::forward<Arg2>(arg2_)),
 
 3954             arg3(std::forward<Arg3>(arg3_)) {}
 
 3957 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
 
 3958           class BoundArg4, 
class... FreeArgs>
 
 3959 class Callback4_const: 
public CallbackArg<FreeArgs...> {
 
 3961   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, BoundArg3, BoundArg4, FreeArgs...) 
const;
 
 3971     (obj->*func)(arg1, arg2, arg3, arg4, free_args...);
 
 3973   template <
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4>
 
 3974   Callback4_const(
const T& obj_, MemFunc func_,
 
 3979                     obj(&obj_), func(func_),
 
 3980             arg1(std::forward<Arg1>(arg1_)),
 
 3981             arg2(std::forward<Arg2>(arg2_)),
 
 3982             arg3(std::forward<Arg3>(arg3_)),
 
 3983             arg4(std::forward<Arg4>(arg4_)) {}
 
 3986 template <
bool unref, 
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
 
 3987           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 3988 class Callback5_const: 
public CallbackArg<FreeArgs...> {
 
 3990   typedef void (T::* MemFunc)(BoundArg1, BoundArg2, BoundArg3,
 
 3991                   BoundArg4, BoundArg5, FreeArgs...) 
const;
 
 4002     (obj->*func)(arg1, arg2, arg3, arg4, arg5, free_args...);
 
 4004   template <
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5>
 
 4005   Callback5_const(
const T& obj_, MemFunc func_,
 
 4011                     obj(&obj_), func(func_),
 
 4012             arg1(std::forward<Arg1>(arg1_)),
 
 4013             arg2(std::forward<Arg2>(arg2_)),
 
 4014             arg3(std::forward<Arg3>(arg3_)),
 
 4015             arg4(std::forward<Arg4>(arg4_)),
 
 4016             arg5(std::forward<Arg5>(arg5_)) {}
 
 4019 template <
class... FreeArgs>
 
 4020 class Callback0_static: 
public CallbackArg<FreeArgs...> {
 
 4022   typedef void (*Func)(FreeArgs...);
 
 4029   Callback0_static(Func func_): func(func_) {}
 
 4032 template <
bool unref, 
class BoundArg, 
class... FreeArgs>
 
 4033 class Callback1_static: 
public CallbackArg<FreeArgs...> {
 
 4035   typedef void (*Func)(BoundArg, FreeArgs...);
 
 4041     func(arg, free_args...);
 
 4043   template <
class Arg>
 
 4044   Callback1_static(Func func_, Arg&& arg_): func(func_), arg(std::forward<Arg>(arg_)) {}
 
 4047 template <
bool unref, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 4048 class Callback2_static: 
public CallbackArg<FreeArgs...> {
 
 4050   typedef void (*Func)(BoundArg1, BoundArg2, FreeArgs...);
 
 4057     func(arg1, arg2, free_args...);
 
 4059   template <
class Arg1, 
class Arg2>
 
 4060   Callback2_static(Func func_, Arg1&& arg1_,
 
 4061            Arg2&& arg2_): func(func_),
 
 4062                                   arg1(std::forward<Arg1>(arg1_)),
 
 4063                                   arg2(std::forward<Arg2>(arg2_)) {}
 
 4066 template <
bool unref, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 4067 class Callback3_static: 
public CallbackArg<FreeArgs...> {
 
 4069   typedef void (*Func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...);
 
 4077     func(arg1, arg2, arg3, free_args...);
 
 4079   template <
class Arg1, 
class Arg2, 
class Arg3>
 
 4080   Callback3_static(Func func_,
 
 4085              arg1(std::forward<Arg1>(arg1_)),
 
 4086              arg2(std::forward<Arg2>(arg2_)),
 
 4087              arg3(std::forward<Arg3>(arg3_)) {}
 
 4090 template <
bool unref, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
 
 4091           class BoundArg4, 
class... FreeArgs>
 
 4092 class Callback4_static: 
public CallbackArg<FreeArgs...> {
 
 4094   typedef void (*Func)(BoundArg1, BoundArg2, BoundArg3, BoundArg4, FreeArgs...);
 
 4103     func(arg1, arg2, arg3, arg4, free_args...);
 
 4105   template <
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4>
 
 4106   Callback4_static(Func func_,
 
 4112              arg1(std::forward<Arg1>(arg1_)),
 
 4113              arg2(std::forward<Arg2>(arg2_)),
 
 4114              arg3(std::forward<Arg3>(arg3_)),
 
 4115              arg4(std::forward<Arg4>(arg4_)) {}
 
 4118 template <
bool unref, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
 
 4119           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 4120 class Callback5_static: 
public CallbackArg<FreeArgs...> {
 
 4122   typedef void (*Func)(BoundArg1, BoundArg2, BoundArg3,
 
 4123                BoundArg4, BoundArg5, FreeArgs...);
 
 4133     func(arg1, arg2, arg3, arg4, arg5, free_args...);
 
 4135   template <
class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5>
 
 4136   Callback5_static(Func func_,
 
 4143              arg1(std::forward<Arg1>(arg1_)),
 
 4144              arg2(std::forward<Arg2>(arg2_)),
 
 4145              arg3(std::forward<Arg3>(arg3_)),
 
 4146              arg4(std::forward<Arg4>(arg4_)),
 
 4147              arg5(std::forward<Arg5>(arg5_)) {}
 
 4155 template <
class T, 
class... FreeArgs>
 
 4156 CallbackArg<FreeArgs...>* make_val(T& t,
 
 4157                    void (T::*func)(FreeArgs...)) {
 
 4158   return new Callback0<T, FreeArgs...>{t, func};
 
 4160 template <
class T, 
class BoundArg, 
class... FreeArgs>
 
 4161 CallbackArg<FreeArgs...>* make_val(T& t,
 
 4162                    void (T::*func)(BoundArg, FreeArgs...),
 
 4163                    const BoundArg& arg) {
 
 4164   return new Callback1<
false, T, BoundArg, FreeArgs...>{t, func, arg};
 
 4166 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 4167 CallbackArg<FreeArgs...>* make_val(T& t,
 
 4168                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 4169                    const BoundArg1& arg1,
 
 4170                    const BoundArg2& arg2) {
 
 4171   return new Callback2<
false, T, BoundArg1, BoundArg2, FreeArgs...>{t, func, arg1, arg2};
 
 4173 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 4174 CallbackArg<FreeArgs...>* make_val(T& t,
 
 4175                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 4176                    const BoundArg1& arg1,
 
 4177                    const BoundArg2& arg2,
 
 4178                    const BoundArg3& arg3) {
 
 4179   return new Callback3<
false, T, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{t, func, arg1, arg2, arg3};
 
 4181 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4182           class BoundArg4, 
class... FreeArgs>
 
 4183 CallbackArg<FreeArgs...>* make_val(T& t,
 
 4184                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4185                            BoundArg4, FreeArgs...),
 
 4186                    const BoundArg1& arg1,
 
 4187                    const BoundArg2& arg2,
 
 4188                    const BoundArg3& arg3,
 
 4189                    const BoundArg4& arg4) {
 
 4190   return new Callback4<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4191                        BoundArg4, FreeArgs...>{t, func, arg1, arg2, arg3, arg4};
 
 4193 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4194           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 4195 CallbackArg<FreeArgs...>* make_val(T& t,
 
 4196                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4197                            BoundArg4, BoundArg5, FreeArgs...),
 
 4198                    const BoundArg1& arg1,
 
 4199                    const BoundArg2& arg2,
 
 4200                    const BoundArg3& arg3,
 
 4201                    const BoundArg4& arg4,
 
 4202                    const BoundArg5& arg5) {
 
 4203   return new Callback5<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4204                        BoundArg4, BoundArg5, FreeArgs...>{t, func, arg1, arg2, arg3, arg4, arg5};
 
 4206 template <
class T, 
class... FreeArgs>
 
 4207 CallbackArg<FreeArgs...>* make_val(
const T& t,
 
 4208                    void (T::*func)(FreeArgs...) 
const) {
 
 4209   return new Callback0_const<T, FreeArgs...>{t, func};
 
 4211 template <
class T, 
class BoundArg, 
class... FreeArgs>
 
 4212 CallbackArg<FreeArgs...>* make_val(
const T& t,
 
 4213                    void (T::*func)(BoundArg, FreeArgs...) 
const,
 
 4214                    const BoundArg& arg) {
 
 4215   return new Callback1_const<
false, T, BoundArg, FreeArgs...>{t, func, arg};
 
 4217 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 4218 CallbackArg<FreeArgs...>* make_val(
const T& t,
 
 4219                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...) 
const,
 
 4220                    const BoundArg1& arg1,
 
 4221                    const BoundArg2& arg2) {
 
 4222   return new Callback2_const<
false, T, BoundArg1, BoundArg2, FreeArgs...>{t, func, arg1, arg2};
 
 4224 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 4225 CallbackArg<FreeArgs...>* make_val(
const T& t,
 
 4226                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...) 
const,
 
 4227                    const BoundArg1& arg1,
 
 4228                    const BoundArg2& arg2,
 
 4229                    const BoundArg3& arg3) {
 
 4230   return new Callback3_const<
false, T, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{t, func, arg1, arg2, arg3};
 
 4232 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4233           class BoundArg4, 
class... FreeArgs>
 
 4234 CallbackArg<FreeArgs...>* make_val(
const T& t,
 
 4235                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4236                            BoundArg4, FreeArgs...) 
const,
 
 4237                    const BoundArg1& arg1,
 
 4238                    const BoundArg2& arg2,
 
 4239                    const BoundArg3& arg3,
 
 4240                    const BoundArg4& arg4) {
 
 4241   return new Callback4_const<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4242                              BoundArg4, FreeArgs...>{t, func, arg1, arg2, arg3, arg4};
 
 4244 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4245           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 4246 CallbackArg<FreeArgs...>* make_val(
const T& t,
 
 4247                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4248                            BoundArg4, BoundArg5, FreeArgs...) 
const,
 
 4249                    const BoundArg1& arg1,
 
 4250                    const BoundArg2& arg2,
 
 4251                    const BoundArg3& arg3,
 
 4252                    const BoundArg4& arg4,
 
 4253                    const BoundArg5& arg5) {
 
 4254   return new Callback5_const<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4255                              BoundArg4, BoundArg5, FreeArgs...>{t, func, arg1, arg2, arg3, arg4, arg5};
 
 4257 template <
class... FreeArgs>
 
 4258 CallbackArg<FreeArgs...>* make_val(
void (*func)(FreeArgs...)) {
 
 4259   return new Callback0_static<FreeArgs...>{func};
 
 4261 template <
class BoundArg, 
class... FreeArgs>
 
 4262 CallbackArg<FreeArgs...>* make_val(
void (*func)(BoundArg, FreeArgs...),
 
 4263                    const BoundArg& arg) {
 
 4264   return new Callback1_static<
false, BoundArg, FreeArgs...>{func, arg};
 
 4266 template <
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 4267 CallbackArg<FreeArgs...>* make_val(
void (*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 4268                    const BoundArg1& arg1,
 
 4269                    const BoundArg2& arg2) {
 
 4270   return new Callback2_static<
false, BoundArg1, BoundArg2, FreeArgs...>{func, arg1, arg2};
 
 4272 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 4273 CallbackArg<FreeArgs...>* make_val(
void (*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 4274                    const BoundArg1& arg1,
 
 4275                    const BoundArg2& arg2,
 
 4276                    const BoundArg3& arg3) {
 
 4277   return new Callback3_static<
false, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{func, arg1, arg2, arg3};
 
 4279 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4280           class BoundArg4, 
class... FreeArgs>
 
 4281 CallbackArg<FreeArgs...>* make_val(
void (*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4282                         BoundArg4, FreeArgs...),
 
 4283                    const BoundArg1& arg1,
 
 4284                    const BoundArg2& arg2,
 
 4285                    const BoundArg3& arg3,
 
 4286                    const BoundArg4& arg4) {
 
 4287   return new Callback4_static<
false, BoundArg1, BoundArg2, BoundArg3,
 
 4288                               BoundArg4, FreeArgs...>{func, arg1, arg2, arg3, arg4};
 
 4290 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4291           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 4292 CallbackArg<FreeArgs...>* make_val(
void (*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4293                         BoundArg4, BoundArg5, FreeArgs...),
 
 4294                    const BoundArg1& arg1,
 
 4295                    const BoundArg2& arg2,
 
 4296                    const BoundArg3& arg3,
 
 4297                    const BoundArg4& arg4,
 
 4298                    const BoundArg5& arg5) {
 
 4299   return new Callback5_static<
false, BoundArg1, BoundArg2, BoundArg3,
 
 4300                               BoundArg4, BoundArg5, FreeArgs...>{func, arg1, arg2, arg3, arg4, arg5};
 
 4302 template <
class... FreeArgs>
 
 4303 CallbackArg<FreeArgs...>* make_val(
const std::function<
void(FreeArgs...)>& f) {
 
 4304   typedef std::function<void(FreeArgs...)> LType;
 
 4305   return new Callback_lambda<LType, FreeArgs...>{f};
 
 4307 template <
class... FreeArgs>
 
 4308 CallbackArg<FreeArgs...>* make_val(std::function<
void(FreeArgs...)>&& f) {
 
 4309   typedef std::function<void(FreeArgs...)> LType;
 
 4310   return new Callback_lambda<LType, FreeArgs...>{std::move(f)};
 
 4313 #ifndef CGU_USE_TUPLE 
 4315 template <
class T, 
class... FreeArgs>
 
 4316 CallbackArg<FreeArgs...>* 
make(T& t,
 
 4317                    void (T::*func)(FreeArgs...)) {
 
 4318   return new Callback0<T, FreeArgs...>{t, func};
 
 4321 template <
class T, 
class... FreeArgs>
 
 4322 CallbackArg<FreeArgs...>* 
make_ref(T& t,
 
 4323                    void (T::*func)(FreeArgs...)) {
 
 4324   return new Callback0<T, FreeArgs...>{t, func};
 
 4327 template <
class T, 
class BoundArg, 
class... FreeArgs>
 
 4328 CallbackArg<FreeArgs...>* 
make(T& t,
 
 4329                    void (T::*func)(BoundArg, FreeArgs...),
 
 4331   return new Callback1<
false, T, BoundArg, FreeArgs...>{t, func, arg};
 
 4334 template <
class T, 
class BoundArg, 
class Arg, 
class... FreeArgs>
 
 4335 CallbackArg<FreeArgs...>* 
make_ref(T& t,
 
 4336                    void (T::*func)(BoundArg, FreeArgs...),
 
 4338   return new Callback1<
true, T, BoundArg, FreeArgs...>{t, func, std::forward<Arg>(arg)};
 
 4341 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 4342 CallbackArg<FreeArgs...>* 
make(T& t,
 
 4343                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 4346   return new Callback2<
false, T, BoundArg1, BoundArg2, FreeArgs...>{t, func, arg1, arg2};
 
 4349 template <
class T, 
class BoundArg1, 
class BoundArg2,
 
 4350           class Arg1, 
class Arg2, 
class... FreeArgs>
 
 4351 CallbackArg<FreeArgs...>* 
make_ref(T& t,
 
 4352                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 4355   return new Callback2<
true, T, BoundArg1, BoundArg2, FreeArgs...>{t, func,
 
 4356                                                                    std::forward<Arg1>(arg1),
 
 4357                                                                    std::forward<Arg2>(arg2)};
 
 4360 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 4361 CallbackArg<FreeArgs...>* 
make(T& t,
 
 4362                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 4366   return new Callback3<
false, T, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{t, func, arg1, arg2, arg3};
 
 4369 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4370           class Arg1, 
class Arg2, 
class Arg3, 
class... FreeArgs>
 
 4371 CallbackArg<FreeArgs...>* 
make_ref(T& t,
 
 4372                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 4376   return new Callback3<
true, T, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{t, func,
 
 4377                                                                               std::forward<Arg1>(arg1),
 
 4378                                                                               std::forward<Arg2>(arg2),
 
 4379                                                                               std::forward<Arg3>(arg3)};
 
 4382 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4383           class BoundArg4, 
class... FreeArgs>
 
 4384 CallbackArg<FreeArgs...>* 
make(T& t,
 
 4385                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4386                            BoundArg4, FreeArgs...),
 
 4391   return new Callback4<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4392                        BoundArg4, FreeArgs...>{t, func, arg1, arg2, arg3, arg4};
 
 4395 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 4396           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class... FreeArgs>
 
 4397 CallbackArg<FreeArgs...>* 
make_ref(T& t,
 
 4398                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4399                            BoundArg4, FreeArgs...),
 
 4404   return new Callback4<
true, T, BoundArg1, BoundArg2, BoundArg3,
 
 4405                        BoundArg4, FreeArgs...>{t, func,
 
 4406                                                std::forward<Arg1>(arg1),
 
 4407                                                std::forward<Arg2>(arg2),
 
 4408                                                std::forward<Arg3>(arg3),
 
 4409                                                std::forward<Arg4>(arg4)};
 
 4412 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4413           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 4414 CallbackArg<FreeArgs...>* 
make(T& t,
 
 4415                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4416                            BoundArg4, BoundArg5, FreeArgs...),
 
 4422   return new Callback5<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4423                        BoundArg4, BoundArg5, FreeArgs...>{t, func, arg1, arg2, arg3, arg4, arg5};
 
 4426 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4, 
class BoundArg5,
 
 4427           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class... FreeArgs>
 
 4428 CallbackArg<FreeArgs...>* 
make_ref(T& t,
 
 4429                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4430                            BoundArg4, BoundArg5, FreeArgs...),
 
 4436   return new Callback5<
true, T, BoundArg1, BoundArg2, BoundArg3,
 
 4437                        BoundArg4, BoundArg5, FreeArgs...>{t, func,
 
 4438                                                           std::forward<Arg1>(arg1),
 
 4439                                                           std::forward<Arg2>(arg2),
 
 4440                                                           std::forward<Arg3>(arg3),
 
 4441                                                           std::forward<Arg4>(arg4),
 
 4442                                                           std::forward<Arg5>(arg5)};
 
 4445 template <
class T, 
class... FreeArgs>
 
 4446 CallbackArg<FreeArgs...>* 
make(
const T& t,
 
 4447                    void (T::*func)(FreeArgs...) 
const) {
 
 4448   return new Callback0_const<T, FreeArgs...>{t, func};
 
 4451 template <
class T, 
class... FreeArgs>
 
 4452 CallbackArg<FreeArgs...>* 
make_ref(
const T& t,
 
 4453                    void (T::*func)(FreeArgs...) 
const) {
 
 4454   return new Callback0_const<T, FreeArgs...>{t, func};
 
 4457 template <
class T, 
class BoundArg, 
class... FreeArgs>
 
 4458 CallbackArg<FreeArgs...>* 
make(
const T& t,
 
 4459                    void (T::*func)(BoundArg, FreeArgs...) 
const,
 
 4461   return new Callback1_const<
false, T, BoundArg, FreeArgs...>{t, func, arg};
 
 4464 template <
class T, 
class BoundArg, 
class Arg, 
class... FreeArgs>
 
 4465 CallbackArg<FreeArgs...>* 
make_ref(
const T& t,
 
 4466                    void (T::*func)(BoundArg, FreeArgs...) 
const,
 
 4468   return new Callback1_const<
true, T, BoundArg, FreeArgs...>{t, func, std::forward<Arg>(arg)};
 
 4471 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 4472 CallbackArg<FreeArgs...>* 
make(
const T& t,
 
 4473                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...) 
const,
 
 4476   return new Callback2_const<
false, T, BoundArg1, BoundArg2, FreeArgs...>{t, func, arg1, arg2};
 
 4479 template <
class T, 
class BoundArg1, 
class BoundArg2,
 
 4480           class Arg1, 
class Arg2, 
class... FreeArgs>
 
 4481 CallbackArg<FreeArgs...>* 
make_ref(
const T& t,
 
 4482                    void (T::*func)(BoundArg1, BoundArg2, FreeArgs...) 
const,
 
 4485   return new Callback2_const<
true, T, BoundArg1, BoundArg2, FreeArgs...>{t, func,
 
 4486                                                                          std::forward<Arg1>(arg1),
 
 4487                                                                          std::forward<Arg2>(arg2)};
 
 4490 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 4491 CallbackArg<FreeArgs...>* 
make(
const T& t,
 
 4492                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...) 
const,
 
 4496   return new Callback3_const<
false, T, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{t, func, arg1, arg2, arg3};
 
 4499 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4500           class Arg1, 
class Arg2, 
class Arg3, 
class... FreeArgs>
 
 4501 CallbackArg<FreeArgs...>* 
make_ref(
const T& t,
 
 4502                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...) 
const,
 
 4506   return new Callback3_const<
true, T, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{t, func,
 
 4507                                                                                     std::forward<Arg1>(arg1),
 
 4508                                                                                     std::forward<Arg2>(arg2),
 
 4509                                                                                     std::forward<Arg3>(arg3)};
 
 4512 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4513           class BoundArg4, 
class... FreeArgs>
 
 4514 CallbackArg<FreeArgs...>* 
make(
const T& t,
 
 4515                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4516                            BoundArg4, FreeArgs...) 
const,
 
 4521   return new Callback4_const<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4522                              BoundArg4, FreeArgs...>{t, func, arg1, arg2, arg3, arg4};
 
 4525 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 4526           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class... FreeArgs>
 
 4527 CallbackArg<FreeArgs...>* 
make_ref(
const T& t,
 
 4528                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4529                            BoundArg4, FreeArgs...) 
const,
 
 4534   return new Callback4_const<
true, T, BoundArg1, BoundArg2, BoundArg3,
 
 4535                              BoundArg4, FreeArgs...>{t, func,
 
 4536                                                      std::forward<Arg1>(arg1),
 
 4537                                                      std::forward<Arg2>(arg2),
 
 4538                                                      std::forward<Arg3>(arg3),
 
 4539                                                      std::forward<Arg4>(arg4)};
 
 4542 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4543           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 4544 CallbackArg<FreeArgs...>* 
make(
const T& t,
 
 4545                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4546                            BoundArg4, BoundArg5, FreeArgs...) 
const,
 
 4552   return new Callback5_const<
false, T, BoundArg1, BoundArg2, BoundArg3,
 
 4553                              BoundArg4, BoundArg5, FreeArgs...>{t, func, arg1, arg2, arg3, arg4, arg5};
 
 4556 template <
class T, 
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4, 
class BoundArg5,
 
 4557           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class... FreeArgs>
 
 4558 CallbackArg<FreeArgs...>* 
make_ref(
const T& t,
 
 4559                    void (T::*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4560                            BoundArg4, BoundArg5, FreeArgs...) 
const,
 
 4566   return new Callback5_const<
true, T, BoundArg1, BoundArg2, BoundArg3,
 
 4567                              BoundArg4, BoundArg5, FreeArgs...>{t, func,
 
 4568                                                                 std::forward<Arg1>(arg1),
 
 4569                                                                 std::forward<Arg2>(arg2),
 
 4570                                                                 std::forward<Arg3>(arg3),
 
 4571                                                                 std::forward<Arg4>(arg4),
 
 4572                                                                 std::forward<Arg5>(arg5)};
 
 4575 template <
class... FreeArgs>
 
 4576 CallbackArg<FreeArgs...>* 
make(
void (*func)(FreeArgs...)) {
 
 4577   return new Callback0_static<FreeArgs...>{func};
 
 4580 template <
class... FreeArgs>
 
 4581 CallbackArg<FreeArgs...>* 
make_ref(
void (*func)(FreeArgs...)) {
 
 4582   return new Callback0_static<FreeArgs...>{func};
 
 4585 template <
class BoundArg, 
class... FreeArgs>
 
 4586 CallbackArg<FreeArgs...>* 
make(
void (*func)(BoundArg, FreeArgs...),
 
 4588   return new Callback1_static<
false, BoundArg, FreeArgs...>{func, arg};
 
 4591 template <
class BoundArg, 
class Arg, 
class... FreeArgs>
 
 4592 CallbackArg<FreeArgs...>* 
make_ref(
void (*func)(BoundArg, FreeArgs...),
 
 4594   return new Callback1_static<
true, BoundArg, FreeArgs...>{func, std::forward<Arg>(arg)};
 
 4597 template <
class BoundArg1, 
class BoundArg2, 
class... FreeArgs>
 
 4598 CallbackArg<FreeArgs...>* 
make(
void (*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 4601   return new Callback2_static<
false, BoundArg1, BoundArg2, FreeArgs...>{func, arg1, arg2};
 
 4604 template <
class BoundArg1, 
class BoundArg2, 
class Arg1, 
class Arg2, 
class... FreeArgs>
 
 4605 CallbackArg<FreeArgs...>* 
make_ref(
void (*func)(BoundArg1, BoundArg2, FreeArgs...),
 
 4608   return new Callback2_static<
true, BoundArg1, BoundArg2, FreeArgs...>{func,
 
 4609                                                                        std::forward<Arg1>(arg1),
 
 4610                                                                        std::forward<Arg2>(arg2)};
 
 4613 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class... FreeArgs>
 
 4614 CallbackArg<FreeArgs...>* 
make(
void (*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 4618   return new Callback3_static<
false, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{func, arg1, arg2, arg3};
 
 4621 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4622           class Arg1, 
class Arg2, 
class Arg3, 
class... FreeArgs>
 
 4623 CallbackArg<FreeArgs...>* 
make_ref(
void (*func)(BoundArg1, BoundArg2, BoundArg3, FreeArgs...),
 
 4627   return new Callback3_static<
true, BoundArg1, BoundArg2, BoundArg3, FreeArgs...>{func,
 
 4628                                                                                   std::forward<Arg1>(arg1),
 
 4629                                                                                   std::forward<Arg2>(arg2),
 
 4630                                                                                   std::forward<Arg3>(arg3)};
 
 4633 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4634           class BoundArg4, 
class... FreeArgs>
 
 4635 CallbackArg<FreeArgs...>* 
make(
void (*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4636                         BoundArg4, FreeArgs...),
 
 4641   return new Callback4_static<
false, BoundArg1, BoundArg2, BoundArg3,
 
 4642                               BoundArg4, FreeArgs...>{func, arg1, arg2, arg3, arg4};
 
 4645 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4,
 
 4646           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class... FreeArgs>
 
 4647 CallbackArg<FreeArgs...>* 
make_ref(
void (*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4648                         BoundArg4, FreeArgs...),
 
 4653   return new Callback4_static<
true, BoundArg1, BoundArg2, BoundArg3,
 
 4654                               BoundArg4, FreeArgs...>{func,
 
 4655                                                       std::forward<Arg1>(arg1),
 
 4656                                                       std::forward<Arg2>(arg2),
 
 4657                                                       std::forward<Arg3>(arg3),
 
 4658                                                       std::forward<Arg4>(arg4)};
 
 4661 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3,
 
 4662           class BoundArg4, 
class BoundArg5, 
class... FreeArgs>
 
 4663 CallbackArg<FreeArgs...>* 
make(
void (*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4664                         BoundArg4, BoundArg5, FreeArgs...),
 
 4670   return new Callback5_static<
false, BoundArg1, BoundArg2, BoundArg3,
 
 4671                               BoundArg4, BoundArg5, FreeArgs...>{func, arg1, arg2, arg3, arg4, arg5};
 
 4674 template <
class BoundArg1, 
class BoundArg2, 
class BoundArg3, 
class BoundArg4, 
class BoundArg5,
 
 4675           class Arg1, 
class Arg2, 
class Arg3, 
class Arg4, 
class Arg5, 
class... FreeArgs>
 
 4676 CallbackArg<FreeArgs...>* 
make_ref(
void (*func)(BoundArg1, BoundArg2, BoundArg3,
 
 4677                         BoundArg4, BoundArg5, FreeArgs...),
 
 4683   return new Callback5_static<
true, BoundArg1, BoundArg2, BoundArg3,
 
 4684                               BoundArg4, BoundArg5, FreeArgs...>{func,
 
 4685                                                                  std::forward<Arg1>(arg1),
 
 4686                                                                  std::forward<Arg2>(arg2),
 
 4687                                                                  std::forward<Arg3>(arg3),
 
 4688                                                                  std::forward<Arg4>(arg4),
 
 4689                                                                  std::forward<Arg5>(arg5)};
 
 4692 #endif // CGU_USE_TUPLE 
 4694 #endif // DOXYGEN_PARSING 
 4726 void post(
const Callback* cb, gint priority = G_PRIORITY_DEFAULT_IDLE,
 
 4727       GMainContext* context = 0);
 
 4778       gint priority = G_PRIORITY_DEFAULT_IDLE, GMainContext* context = 0);
 
 4823       class = 
typename std::enable_if<!std::is_convertible<typename std::remove_reference<F>::type,
 
 4825 void post(F&& func, gint priority = G_PRIORITY_DEFAULT_IDLE,
 
 4826       GMainContext* context = 0) {
 
 4827   post(lambda<>(std::forward<F>(func)), priority, context);
 
 4888       class = 
typename std::enable_if<!std::is_convertible<typename std::remove_reference<F>::type,
 
 4891       gint priority = G_PRIORITY_DEFAULT_IDLE, GMainContext* context = 0) {
 
 4892   post(lambda<>(std::forward<F>(func)), r, priority, context);