src/third_party/libjingle/source/talk/base/genericslot.h

   1 // This file was GENERATED by command:
   2 //     pump.py genericslot.h.pump
   3 // DO NOT EDIT BY HAND!!!
   4
   5 /*
   6  * libjingle
   7  * Copyright 2014 Google Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are met:
  11  *
  12  *  1. Redistributions of source code must retain the above copyright notice,
  13  *     this list of conditions and the following disclaimer.
  14  *  2. Redistributions in binary form must reproduce the above copyright notice,
  15  *     this list of conditions and the following disclaimer in the documentation
  16  *     and/or other materials provided with the distribution.
  17  *  3. The name of the author may not be used to endorse or promote products
  18  *     derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  21  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  22  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  23  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  26  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  28  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  29  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #ifndef TALK_BASE_GENERICSLOT_H_
  33 #define TALK_BASE_GENERICSLOT_H_
  34
  35 // To generate genericslot.h from genericslot.h.pump, execute:
  36 // /home/build/google3/third_party/gtest/scripts/pump.py genericslot.h.pump
  37
  38 // Generic-slots are pure slots that can be hooked up to signals. They're
  39 // mainly intended to be used in tests where we want to check if a signal
  40 // was invoked and what arguments were passed. NOTE: They do not do any
  41 // lifetime management of the arguments received via callbacks.
  42 //
  43 // Example:
  44 //   /* Some signal */
  45 //   sigslot::signal1<int> foo;
  46 //
  47 //   /* We want to monitor foo in some test */
  48 //   talk_base::GenericSlot1<int> slot(&foo, 0);
  49 //   foo.emit(5);
  50 //   EXPECT_TRUE(slot.callback_received());
  51 //   EXPECT_EQ(5, *(slot.arg1()));
  52 //
  53
  54 #include "talk/base/constructormagic.h"
  55 #include "talk/base/sigslot.h"
  56
  57 namespace talk_base {
  58
  59 template <class A1>
  60 class GenericSlot1 : public sigslot::has_slots<> {
  61  public:
  62   GenericSlot1(sigslot::signal1<A1>* signal,
  63                 const A1& arg1_initial)
  64       : arg1_initial_(arg1_initial) {
  65     Reset();
  66     signal->connect(this, &GenericSlot1::OnSignalCallback);
  67   }
  68
  69   void Reset() {
  70     callback_received_ = false;
  71     arg1_ = arg1_initial_;
  72   }
  73
  74   bool callback_received() const { return callback_received_; }
  75   const A1& arg1() const { return arg1_; }
  76
  77  private:
  78   void OnSignalCallback(A1 arg1) {
  79     callback_received_ = true;
  80     arg1_ = arg1;
  81   }
  82
  83   bool callback_received_;
  84   A1 arg1_initial_, arg1_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(GenericSlot1);
  87 };
  88
  89 template <class A1, class A2>
  90 class GenericSlot2 : public sigslot::has_slots<> {
  91  public:
  92   GenericSlot2(sigslot::signal2<A1, A2>* signal,
  93                 const A1& arg1_initial, const A2& arg2_initial)
  94       : arg1_initial_(arg1_initial), arg2_initial_(arg2_initial) {
  95     Reset();
  96     signal->connect(this, &GenericSlot2::OnSignalCallback);
  97   }
  98
  99   void Reset() {
 100     callback_received_ = false;
 101     arg1_ = arg1_initial_;
 102     arg2_ = arg2_initial_;
 103   }
 104
 105   bool callback_received() const { return callback_received_; }
 106   const A1& arg1() const { return arg1_; }
 107   const A2& arg2() const { return arg2_; }
 108
 109  private:
 110   void OnSignalCallback(A1 arg1, A2 arg2) {
 111     callback_received_ = true;
 112     arg1_ = arg1;
 113     arg2_ = arg2;
 114   }
 115
 116   bool callback_received_;
 117   A1 arg1_initial_, arg1_;
 118   A2 arg2_initial_, arg2_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(GenericSlot2);
 121 };
 122
 123 template <class A1, class A2, class A3>
 124 class GenericSlot3 : public sigslot::has_slots<> {
 125  public:
 126   GenericSlot3(sigslot::signal3<A1, A2, A3>* signal,
 127                 const A1& arg1_initial, const A2& arg2_initial,
 128                     const A3& arg3_initial)
 129       : arg1_initial_(arg1_initial), arg2_initial_(arg2_initial),
 130           arg3_initial_(arg3_initial) {
 131     Reset();
 132     signal->connect(this, &GenericSlot3::OnSignalCallback);
 133   }
 134
 135   void Reset() {
 136     callback_received_ = false;
 137     arg1_ = arg1_initial_;
 138     arg2_ = arg2_initial_;
 139     arg3_ = arg3_initial_;
 140   }
 141
 142   bool callback_received() const { return callback_received_; }
 143   const A1& arg1() const { return arg1_; }
 144   const A2& arg2() const { return arg2_; }
 145   const A3& arg3() const { return arg3_; }
 146
 147  private:
 148   void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3) {
 149     callback_received_ = true;
 150     arg1_ = arg1;
 151     arg2_ = arg2;
 152     arg3_ = arg3;
 153   }
 154
 155   bool callback_received_;
 156   A1 arg1_initial_, arg1_;
 157   A2 arg2_initial_, arg2_;
 158   A3 arg3_initial_, arg3_;
 159
 160   DISALLOW_COPY_AND_ASSIGN(GenericSlot3);
 161 };
 162
 163 template <class A1, class A2, class A3, class A4>
 164 class GenericSlot4 : public sigslot::has_slots<> {
 165  public:
 166   GenericSlot4(sigslot::signal4<A1, A2, A3, A4>* signal,
 167                 const A1& arg1_initial, const A2& arg2_initial,
 168                     const A3& arg3_initial, const A4& arg4_initial)
 169       : arg1_initial_(arg1_initial), arg2_initial_(arg2_initial),
 170           arg3_initial_(arg3_initial), arg4_initial_(arg4_initial) {
 171     Reset();
 172     signal->connect(this, &GenericSlot4::OnSignalCallback);
 173   }
 174
 175   void Reset() {
 176     callback_received_ = false;
 177     arg1_ = arg1_initial_;
 178     arg2_ = arg2_initial_;
 179     arg3_ = arg3_initial_;
 180     arg4_ = arg4_initial_;
 181   }
 182
 183   bool callback_received() const { return callback_received_; }
 184   const A1& arg1() const { return arg1_; }
 185   const A2& arg2() const { return arg2_; }
 186   const A3& arg3() const { return arg3_; }
 187   const A4& arg4() const { return arg4_; }
 188
 189  private:
 190   void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3, A4 arg4) {
 191     callback_received_ = true;
 192     arg1_ = arg1;
 193     arg2_ = arg2;
 194     arg3_ = arg3;
 195     arg4_ = arg4;
 196   }
 197
 198   bool callback_received_;
 199   A1 arg1_initial_, arg1_;
 200   A2 arg2_initial_, arg2_;
 201   A3 arg3_initial_, arg3_;
 202   A4 arg4_initial_, arg4_;
 203
 204   DISALLOW_COPY_AND_ASSIGN(GenericSlot4);
 205 };
 206
 207 template <class A1, class A2, class A3, class A4, class A5>
 208 class GenericSlot5 : public sigslot::has_slots<> {
 209  public:
 210   GenericSlot5(sigslot::signal5<A1, A2, A3, A4, A5>* signal,
 211                 const A1& arg1_initial, const A2& arg2_initial,
 212                     const A3& arg3_initial, const A4& arg4_initial,
 213                     const A5& arg5_initial)
 214       : arg1_initial_(arg1_initial), arg2_initial_(arg2_initial),
 215           arg3_initial_(arg3_initial), arg4_initial_(arg4_initial),
 216           arg5_initial_(arg5_initial) {
 217     Reset();
 218     signal->connect(this, &GenericSlot5::OnSignalCallback);
 219   }
 220
 221   void Reset() {
 222     callback_received_ = false;
 223     arg1_ = arg1_initial_;
 224     arg2_ = arg2_initial_;
 225     arg3_ = arg3_initial_;
 226     arg4_ = arg4_initial_;
 227     arg5_ = arg5_initial_;
 228   }
 229
 230   bool callback_received() const { return callback_received_; }
 231   const A1& arg1() const { return arg1_; }
 232   const A2& arg2() const { return arg2_; }
 233   const A3& arg3() const { return arg3_; }
 234   const A4& arg4() const { return arg4_; }
 235   const A5& arg5() const { return arg5_; }
 236
 237  private:
 238   void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5) {
 239     callback_received_ = true;
 240     arg1_ = arg1;
 241     arg2_ = arg2;
 242     arg3_ = arg3;
 243     arg4_ = arg4;
 244     arg5_ = arg5;
 245   }
 246
 247   bool callback_received_;
 248   A1 arg1_initial_, arg1_;
 249   A2 arg2_initial_, arg2_;
 250   A3 arg3_initial_, arg3_;
 251   A4 arg4_initial_, arg4_;
 252   A5 arg5_initial_, arg5_;
 253
 254   DISALLOW_COPY_AND_ASSIGN(GenericSlot5);
 255 };
 256 }  // namespace talk_base
 257
 258 #endif  // TALK_BASE_GENERICSLOT_H_