boost/boost/signal.hpp

   1 // Boost.Signals library
   2 //
   3 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
   4 //
   5 // Permission to copy, use, sell and distribute this software is granted
   6 // provided this copyright notice appears in all copies.
   7 // Permission to modify the code and to distribute modified code is granted
   8 // provided this copyright notice appears in all copies, and a notice
   9 // that the code was modified is included with the copyright notice.
  10 //
  11 // This software is provided "as is" without express or implied warranty,
  12 // and with no claim as to its suitability for any purpose.
  13
  14 // For more information, see http://www.boost.org
  15
  16 #ifndef BOOST_SIGNAL_HPP
  17 #define BOOST_SIGNAL_HPP
  18
  19 #define BOOST_SIGNALS_MAX_ARGS 10
  20
  21 #include <boost/config.hpp>
  22 #include <boost/signals/signal0.hpp>
  23 #include <boost/signals/signal1.hpp>
  24 #include <boost/signals/signal2.hpp>
  25 #include <boost/signals/signal3.hpp>
  26 #include <boost/signals/signal4.hpp>
  27 #include <boost/signals/signal5.hpp>
  28 #include <boost/signals/signal6.hpp>
  29 #include <boost/signals/signal7.hpp>
  30 #include <boost/signals/signal8.hpp>
  31 #include <boost/signals/signal9.hpp>
  32 #include <boost/signals/signal10.hpp>
  33
  34 namespace boost {
  35   namespace signals {
  36     namespace detail {
  37       // The unusable class is a placeholder for unused function arguments.
  38       struct unused {};
  39
  40       // value=1 if the given type is not "unused"
  41       template<typename T>
  42       struct count_if_used
  43       {
  44         BOOST_STATIC_CONSTANT(int, value = 1);
  45       };
  46
  47       // value=0 for unused types
  48       template<>
  49       struct count_if_used<unused>
  50       {
  51         BOOST_STATIC_CONSTANT(int, value = 0);
  52       };
  53
  54       // Count the number of arguments (from the given set) which are not
  55       // "unused" (therefore, count those arguments that are used).
  56       template<typename T1, typename T2, typename T3, typename T4,
  57                typename T5, typename T6, typename T7, typename T8,
  58                typename T9, typename T10>
  59       struct count_used_args
  60       {
  61         BOOST_STATIC_CONSTANT(int, value =
  62                               (count_if_used<T1>::value +
  63                                count_if_used<T2>::value +
  64                                count_if_used<T3>::value +
  65                                count_if_used<T4>::value +
  66                                count_if_used<T5>::value +
  67                                count_if_used<T6>::value +
  68                                count_if_used<T7>::value +
  69                                count_if_used<T8>::value +
  70                                count_if_used<T9>::value +
  71                                count_if_used<T10>::value));
  72       };
  73
  74       // Choose the appropriate underlying implementation
  75       template<int Args> struct real_get_signal_impl {};
  76
  77       template<>
  78       struct real_get_signal_impl<0>
  79       {
  80         template<
  81           typename R,
  82           typename T1,
  83           typename T2,
  84           typename T3,
  85           typename T4,
  86           typename T5,
  87           typename T6,
  88           typename T7,
  89           typename T8,
  90           typename T9,
  91           typename T10,
  92           typename Combiner = last_value<R>
  93         >
  94         struct params
  95         {
  96           typedef signal0<R, Combiner> type;
  97         };
  98       };
  99
 100       template<>
 101       struct real_get_signal_impl<1>
 102       {
 103         template<
 104           typename R,
 105           typename T1,
 106           typename T2,
 107           typename T3,
 108           typename T4,
 109           typename T5,
 110           typename T6,
 111           typename T7,
 112           typename T8,
 113           typename T9,
 114           typename T10,
 115           typename Combiner = last_value<R>
 116         >
 117         struct params
 118         {
 119           typedef signal1<R, T1, Combiner> type;
 120         };
 121       };
 122
 123       template<>
 124       struct real_get_signal_impl<2>
 125       {
 126         template<
 127           typename R,
 128           typename T1,
 129           typename T2,
 130           typename T3,
 131           typename T4,
 132           typename T5,
 133           typename T6,
 134           typename T7,
 135           typename T8,
 136           typename T9,
 137           typename T10,
 138           typename Combiner = last_value<R>
 139         >
 140         struct params
 141         {
 142           typedef signal2<R, T1, T2, Combiner> type;
 143         };
 144       };
 145
 146       template<>
 147       struct real_get_signal_impl<3>
 148       {
 149         template<
 150           typename R,
 151           typename T1,
 152           typename T2,
 153           typename T3,
 154           typename T4,
 155           typename T5,
 156           typename T6,
 157           typename T7,
 158           typename T8,
 159           typename T9,
 160           typename T10,
 161           typename Combiner = last_value<R>
 162         >
 163         struct params
 164         {
 165           typedef signal3<R, T1, T2, T3, Combiner> type;
 166         };
 167       };
 168
 169       template<>
 170       struct real_get_signal_impl<4>
 171       {
 172         template<
 173           typename R,
 174           typename T1,
 175           typename T2,
 176           typename T3,
 177           typename T4,
 178           typename T5,
 179           typename T6,
 180           typename T7,
 181           typename T8,
 182           typename T9,
 183           typename T10,
 184           typename Combiner = last_value<R>
 185         >
 186         struct params
 187         {
 188           typedef signal4<R, T1, T2, T3, T4, Combiner> type;
 189         };
 190       };
 191
 192       template<>
 193       struct real_get_signal_impl<5>
 194       {
 195         template<
 196           typename R,
 197           typename T1,
 198           typename T2,
 199           typename T3,
 200           typename T4,
 201           typename T5,
 202           typename T6,
 203           typename T7,
 204           typename T8,
 205           typename T9,
 206           typename T10,
 207           typename Combiner = last_value<R>
 208         >
 209         struct params
 210         {
 211           typedef signal5<R, T1, T2, T3, T4, T5, Combiner>
 212           type;
 213         };
 214       };
 215
 216       template<>
 217       struct real_get_signal_impl<6>
 218       {
 219         template<
 220           typename R,
 221           typename T1,
 222           typename T2,
 223           typename T3,
 224           typename T4,
 225           typename T5,
 226           typename T6,
 227           typename T7,
 228           typename T8,
 229           typename T9,
 230           typename T10,
 231           typename Combiner = last_value<R>
 232         >
 233         struct params
 234         {
 235           typedef signal6<R, T1, T2, T3, T4, T5, T6, Combiner> type;
 236         };
 237       };
 238
 239       template<>
 240       struct real_get_signal_impl<7>
 241       {
 242         template<
 243           typename R,
 244           typename T1,
 245           typename T2,
 246           typename T3,
 247           typename T4,
 248           typename T5,
 249           typename T6,
 250           typename T7,
 251           typename T8,
 252           typename T9,
 253           typename T10,
 254           typename Combiner = last_value<R>
 255         >
 256         struct params
 257         {
 258           typedef signal7<R, T1, T2, T3, T4, T5, T6, T7, Combiner> type;
 259         };
 260       };
 261
 262       template<>
 263       struct real_get_signal_impl<8>
 264       {
 265         template<
 266           typename R,
 267           typename T1,
 268           typename T2,
 269           typename T3,
 270           typename T4,
 271           typename T5,
 272           typename T6,
 273           typename T7,
 274           typename T8,
 275           typename T9,
 276           typename T10,
 277           typename Combiner = last_value<R>
 278         >
 279         struct params
 280         {
 281           typedef signal8<R, T1, T2, T3, T4, T5, T6, T7, T8, Combiner> type;
 282         };
 283       };
 284
 285       template<>
 286       struct real_get_signal_impl<9>
 287       {
 288         template<
 289           typename R,
 290           typename T1,
 291           typename T2,
 292           typename T3,
 293           typename T4,
 294           typename T5,
 295           typename T6,
 296           typename T7,
 297           typename T8,
 298           typename T9,
 299           typename T10,
 300           typename Combiner = last_value<R>
 301         >
 302         struct params
 303         {
 304           typedef signal9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Combiner> type;
 305         };
 306       };
 307
 308       template<>
 309       struct real_get_signal_impl<10>
 310       {
 311         template<
 312           typename R,
 313           typename T1,
 314           typename T2,
 315           typename T3,
 316           typename T4,
 317           typename T5,
 318           typename T6,
 319           typename T7,
 320           typename T8,
 321           typename T9,
 322           typename T10,
 323           typename Combiner = last_value<R>
 324         >
 325         struct params
 326         {
 327           typedef signal10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
 328                            Combiner> type;
 329         };
 330       };
 331
 332       template<
 333         typename R,
 334         typename T1,
 335         typename T2,
 336         typename T3,
 337         typename T4,
 338         typename T5,
 339         typename T6,
 340         typename T7,
 341         typename T8,
 342         typename T9,
 343         typename T10,
 344         typename Combiner = last_value<R>
 345       >
 346       struct get_signal_impl
 347       {
 348         typedef typename real_get_signal_impl<
 349           (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
 350           >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
 351                              Combiner>::type
 352         type;
 353       };
 354     } // end namespace detail
 355   } // end namespace signals
 356
 357   // Very lightweight wrapper around the signalN classes that allows signals to
 358   // be created where the number of arguments does not need to be part of the
 359   // class name.
 360   template<
 361     typename R,
 362     typename T1  = signals::detail::unused,
 363     typename T2  = signals::detail::unused,
 364     typename T3  = signals::detail::unused,
 365     typename T4  = signals::detail::unused,
 366     typename T5  = signals::detail::unused,
 367     typename T6  = signals::detail::unused,
 368     typename T7  = signals::detail::unused,
 369     typename T8  = signals::detail::unused,
 370     typename T9  = signals::detail::unused,
 371     typename T10 = signals::detail::unused
 372   >
 373   class signal :
 374     public signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5, T6, T7,
 375                                             T8, T9, T10>::type
 376   {
 377   public:
 378     template<typename Combiner>
 379     struct combiner {
 380       typedef typename signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5,
 381                                                         T6, T7, T8, T9, T10,
 382                                                         Combiner>::type
 383         type;
 384     };
 385   };
 386 } // end namespace boost
 387
 388 #endif // BOOST_SIGNAL_HPP