]> git.lyx.org Git - lyx.git/blobdiff - boost/boost/signal.hpp
typos
[lyx.git] / boost / boost / signal.hpp
index a7400096cab6fdbc23a2ea50d7449d0a5c935429..d1538e110d194865d390d9e2ff093d085544e64a 100644 (file)
@@ -1,24 +1,21 @@
 // Boost.Signals library
-//
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-// For more information, see http://www.boost.org
+
+// Copyright Douglas Gregor 2001-2006. Use, modification and
+// distribution is subject to the Boost Software License, Version
+// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/signals
 
 #ifndef BOOST_SIGNAL_HPP
 #define BOOST_SIGNAL_HPP
 
-#define BOOST_SIGNALS_MAX_ARGS 10
+#ifndef BOOST_SIGNALS_MAX_ARGS
+#  define BOOST_SIGNALS_MAX_ARGS 10
+#endif
 
 #include <boost/config.hpp>
+#include <boost/type_traits/function_traits.hpp>
 #include <boost/signals/signal0.hpp>
 #include <boost/signals/signal1.hpp>
 #include <boost/signals/signal2.hpp>
 #include <boost/signals/signal8.hpp>
 #include <boost/signals/signal9.hpp>
 #include <boost/signals/signal10.hpp>
+#include <boost/function.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
 
 namespace boost {
-  namespace signals {
+#ifndef BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
-      // The unusable class is a placeholder for unused function arguments.
-      struct unused {};
+      template<int Arity,
+               typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl;
 
-      // value=1 if the given type is not "unused"
-      template<typename T>
-      struct count_if_used
-      {
-        BOOST_STATIC_CONSTANT(int, value = 1);
-      };
-    
-      // value=0 for unused types
-      template<>
-      struct count_if_used<unused>
-      {
-        BOOST_STATIC_CONSTANT(int, value = 0);
-      };
-    
-      // Count the number of arguments (from the given set) which are not 
-      // "unused" (therefore, count those arguments that are used).
-      template<typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7, typename T8, 
-               typename T9, typename T10>
-      struct count_used_args
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<0, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        BOOST_STATIC_CONSTANT(int, value = 
-                              (count_if_used<T1>::value + 
-                               count_if_used<T2>::value +
-                               count_if_used<T3>::value + 
-                               count_if_used<T4>::value +
-                               count_if_used<T5>::value + 
-                               count_if_used<T6>::value +
-                               count_if_used<T7>::value + 
-                               count_if_used<T8>::value +
-                               count_if_used<T9>::value +
-                               count_if_used<T10>::value));
-      };
-
-      // Choose the appropriate underlying implementation
-      template<int Args> struct real_get_signal_impl {};
+        typedef function_traits<Signature> traits;
 
-      template<>
-      struct real_get_signal_impl<0>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal0<R, Combiner> type;
-        };
+      public:
+        typedef signal0<typename traits::result_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<1>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<1, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal1<R, T1, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal1<typename traits::result_type,
+                        typename traits::arg1_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<2>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<2, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal2<R, T1, T2, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal2<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<3>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<3, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal3<R, T1, T2, T3, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal3<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        typename traits::arg3_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<4>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<4, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal4<R, T1, T2, T3, T4, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal4<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        typename traits::arg3_type,
+                        typename traits::arg4_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<5>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<5, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal5<R, T1, T2, T3, T4, T5, Combiner> 
-          type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal5<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        typename traits::arg3_type,
+                        typename traits::arg4_type,
+                        typename traits::arg5_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<6>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<6, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal6<R, T1, T2, T3, T4, T5, T6, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal6<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        typename traits::arg3_type,
+                        typename traits::arg4_type,
+                        typename traits::arg5_type,
+                        typename traits::arg6_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<7>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<7, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal7<R, T1, T2, T3, T4, T5, T6, T7, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal7<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        typename traits::arg3_type,
+                        typename traits::arg4_type,
+                        typename traits::arg5_type,
+                        typename traits::arg6_type,
+                        typename traits::arg7_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<8>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<8, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal8<R, T1, T2, T3, T4, T5, T6, T7, T8, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal8<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        typename traits::arg3_type,
+                        typename traits::arg4_type,
+                        typename traits::arg5_type,
+                        typename traits::arg6_type,
+                        typename traits::arg7_type,
+                        typename traits::arg8_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<9>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<9, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal9<typename traits::result_type,
+                        typename traits::arg1_type,
+                        typename traits::arg2_type,
+                        typename traits::arg3_type,
+                        typename traits::arg4_type,
+                        typename traits::arg5_type,
+                        typename traits::arg6_type,
+                        typename traits::arg7_type,
+                        typename traits::arg8_type,
+                        typename traits::arg9_type,
+                        Combiner,
+                        Group,
+                        GroupCompare,
+                        SlotFunction> type;
       };
 
-      template<>
-      struct real_get_signal_impl<10>
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      class real_get_signal_impl<10, Signature, Combiner, Group, GroupCompare,
+                                 SlotFunction>
       {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Combiner = last_value<R>
-        >
-        struct params
-        {
-          typedef signal10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                           Combiner> type;
-        };
+        typedef function_traits<Signature> traits;
+
+      public:
+        typedef signal10<typename traits::result_type,
+                         typename traits::arg1_type,
+                         typename traits::arg2_type,
+                         typename traits::arg3_type,
+                         typename traits::arg4_type,
+                         typename traits::arg5_type,
+                         typename traits::arg6_type,
+                         typename traits::arg7_type,
+                         typename traits::arg8_type,
+                         typename traits::arg9_type,
+                         typename traits::arg10_type,
+                         Combiner,
+                         Group,
+                         GroupCompare,
+                         SlotFunction> type;
       };
 
-      template<
-        typename R, 
-        typename T1, 
-        typename T2, 
-        typename T3, 
-        typename T4,
-        typename T5, 
-        typename T6, 
-        typename T7, 
-        typename T8, 
-        typename T9,
-        typename T10,
-        typename Combiner = last_value<R>
-      >
-      struct get_signal_impl
+      template<typename Signature,
+               typename Combiner,
+               typename Group,
+               typename GroupCompare,
+               typename SlotFunction>
+      struct get_signal_impl :
+        public real_get_signal_impl<(function_traits<Signature>::arity),
+                                    Signature,
+                                    Combiner,
+                                    Group,
+                                    GroupCompare,
+                                    SlotFunction>
       {
-        typedef typename real_get_signal_impl<
-          (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
-          >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Combiner>::type
-        type;
       };
+
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 
   // Very lightweight wrapper around the signalN classes that allows signals to
   // be created where the number of arguments does not need to be part of the
   // class name.
   template<
-    typename R, 
-    typename T1  = signals::detail::unused, 
-    typename T2  = signals::detail::unused,
-    typename T3  = signals::detail::unused,
-    typename T4  = signals::detail::unused,
-    typename T5  = signals::detail::unused,
-    typename T6  = signals::detail::unused,
-    typename T7  = signals::detail::unused,
-    typename T8  = signals::detail::unused,
-    typename T9  = signals::detail::unused,
-    typename T10 = signals::detail::unused
+    typename Signature, // function type R (T1, T2, ..., TN)
+    typename Combiner = last_value<typename function_traits<Signature>::result_type>,
+    typename Group = int,
+    typename GroupCompare = std::less<Group>,
+    typename SlotFunction = function<Signature>
   >
   class signal :
-    public signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                            T8, T9, T10>::type
+    public BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<Signature,
+                                                            Combiner,
+                                                            Group,
+                                                            GroupCompare,
+                                                            SlotFunction>::type
   {
+    typedef typename BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<
+                       Signature,
+                       Combiner,
+                       Group,
+                       GroupCompare,
+                       SlotFunction>::type base_type;
+
   public:
-    template<typename Combiner>
-    struct combiner {
-      typedef typename signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5,
-                                                        T6, T7, T8, T9, T10, 
-                                                        Combiner>::type
-        type;
-    };
+    explicit signal(const Combiner& combiner = Combiner(),
+                    const GroupCompare& group_compare = GroupCompare()) :
+      base_type(combiner, group_compare)
+    {
+    }
   };
+#endif // ndef BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+
 } // end namespace boost
 
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
 #endif // BOOST_SIGNAL_HPP