src/mojo/public/cpp/bindings/callback.h

   1 // This file was GENERATED by command:
   2 //     pump.py callback.h.pump
   3 // DO NOT EDIT BY HAND!!!
   4
   5
   6
   7 // Copyright 2014 The Chromium Authors. All rights reserved.
   8 // Use of this source code is governed by a BSD-style license that can be
   9 // found in the LICENSE file.
  10
  11 #ifndef MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_
  12 #define MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_
  13
  14 #include "mojo/public/cpp/bindings/lib/callback_internal.h"
  15 #include "mojo/public/cpp/bindings/lib/shared_ptr.h"
  16 #include "mojo/public/cpp/bindings/lib/template_util.h"
  17
  18 namespace mojo {
  19
  20 template <typename Sig>
  21 class Callback;
  22
  23 template <>
  24 class Callback<void()> {
  25  public:
  26   struct Runnable {
  27     virtual ~Runnable() {}
  28     virtual void Run() const = 0;
  29   };
  30
  31   Callback() {}
  32
  33   // The Callback assumes ownership of |runnable|.
  34   explicit Callback(Runnable* runnable) : sink_(runnable) {}
  35
  36   // Any class that is copy-constructable and has a compatible Run method may
  37   // be adapted to a Callback using this constructor.
  38   template <typename Sink>
  39   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
  40
  41   void Run() const {
  42     if (sink_.get())
  43       sink_->Run();
  44   }
  45
  46   bool is_null() const {
  47     return !sink_.get();
  48   }
  49
  50  private:
  51   template <typename Sink>
  52   struct Adapter : public Runnable {
  53     explicit Adapter(const Sink& sink) : sink(sink) {}
  54     virtual void Run() const MOJO_OVERRIDE {
  55       sink.Run();
  56     }
  57     Sink sink;
  58   };
  59
  60   internal::SharedPtr<Runnable> sink_;
  61 };
  62
  63 template <typename A1>
  64 class Callback<void(A1)> {
  65  public:
  66   struct Runnable {
  67     virtual ~Runnable() {}
  68     virtual void Run(
  69         typename internal::Callback_ParamTraits<A1>::ForwardType a1) const = 0;
  70   };
  71
  72   Callback() {}
  73
  74   // The Callback assumes ownership of |runnable|.
  75   explicit Callback(Runnable* runnable) : sink_(runnable) {}
  76
  77   // Any class that is copy-constructable and has a compatible Run method may
  78   // be adapted to a Callback using this constructor.
  79   template <typename Sink>
  80   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
  81
  82   void Run(typename internal::Callback_ParamTraits<A1>::ForwardType a1) const {
  83     if (sink_.get())
  84       sink_->Run(internal::Forward(a1));
  85   }
  86
  87   bool is_null() const {
  88     return !sink_.get();
  89   }
  90
  91  private:
  92   template <typename Sink>
  93   struct Adapter : public Runnable {
  94     explicit Adapter(const Sink& sink) : sink(sink) {}
  95     virtual void Run(
  96         typename internal::Callback_ParamTraits<A1>::ForwardType a1) const
  97             MOJO_OVERRIDE {
  98       sink.Run(internal::Forward(a1));
  99     }
 100     Sink sink;
 101   };
 102
 103   internal::SharedPtr<Runnable> sink_;
 104 };
 105
 106 template <typename A1, typename A2>
 107 class Callback<void(A1, A2)> {
 108  public:
 109   struct Runnable {
 110     virtual ~Runnable() {}
 111     virtual void Run(
 112         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 113         typename internal::Callback_ParamTraits<A2>::ForwardType a2) const = 0;
 114   };
 115
 116   Callback() {}
 117
 118   // The Callback assumes ownership of |runnable|.
 119   explicit Callback(Runnable* runnable) : sink_(runnable) {}
 120
 121   // Any class that is copy-constructable and has a compatible Run method may
 122   // be adapted to a Callback using this constructor.
 123   template <typename Sink>
 124   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
 125
 126   void Run(
 127       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 128       typename internal::Callback_ParamTraits<A2>::ForwardType a2) const {
 129     if (sink_.get())
 130       sink_->Run(
 131           internal::Forward(a1),
 132           internal::Forward(a2));
 133   }
 134
 135   bool is_null() const {
 136     return !sink_.get();
 137   }
 138
 139  private:
 140   template <typename Sink>
 141   struct Adapter : public Runnable {
 142     explicit Adapter(const Sink& sink) : sink(sink) {}
 143     virtual void Run(
 144         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 145         typename internal::Callback_ParamTraits<A2>::ForwardType a2) const
 146             MOJO_OVERRIDE {
 147       sink.Run(
 148           internal::Forward(a1),
 149           internal::Forward(a2));
 150     }
 151     Sink sink;
 152   };
 153
 154   internal::SharedPtr<Runnable> sink_;
 155 };
 156
 157 template <typename A1, typename A2, typename A3>
 158 class Callback<void(A1, A2, A3)> {
 159  public:
 160   struct Runnable {
 161     virtual ~Runnable() {}
 162     virtual void Run(
 163         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 164         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 165         typename internal::Callback_ParamTraits<A3>::ForwardType a3) const = 0;
 166   };
 167
 168   Callback() {}
 169
 170   // The Callback assumes ownership of |runnable|.
 171   explicit Callback(Runnable* runnable) : sink_(runnable) {}
 172
 173   // Any class that is copy-constructable and has a compatible Run method may
 174   // be adapted to a Callback using this constructor.
 175   template <typename Sink>
 176   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
 177
 178   void Run(
 179       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 180       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 181       typename internal::Callback_ParamTraits<A3>::ForwardType a3) const {
 182     if (sink_.get())
 183       sink_->Run(
 184           internal::Forward(a1),
 185           internal::Forward(a2),
 186           internal::Forward(a3));
 187   }
 188
 189   bool is_null() const {
 190     return !sink_.get();
 191   }
 192
 193  private:
 194   template <typename Sink>
 195   struct Adapter : public Runnable {
 196     explicit Adapter(const Sink& sink) : sink(sink) {}
 197     virtual void Run(
 198         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 199         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 200         typename internal::Callback_ParamTraits<A3>::ForwardType a3) const
 201             MOJO_OVERRIDE {
 202       sink.Run(
 203           internal::Forward(a1),
 204           internal::Forward(a2),
 205           internal::Forward(a3));
 206     }
 207     Sink sink;
 208   };
 209
 210   internal::SharedPtr<Runnable> sink_;
 211 };
 212
 213 template <typename A1, typename A2, typename A3, typename A4>
 214 class Callback<void(A1, A2, A3, A4)> {
 215  public:
 216   struct Runnable {
 217     virtual ~Runnable() {}
 218     virtual void Run(
 219         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 220         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 221         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 222         typename internal::Callback_ParamTraits<A4>::ForwardType a4) const = 0;
 223   };
 224
 225   Callback() {}
 226
 227   // The Callback assumes ownership of |runnable|.
 228   explicit Callback(Runnable* runnable) : sink_(runnable) {}
 229
 230   // Any class that is copy-constructable and has a compatible Run method may
 231   // be adapted to a Callback using this constructor.
 232   template <typename Sink>
 233   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
 234
 235   void Run(
 236       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 237       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 238       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 239       typename internal::Callback_ParamTraits<A4>::ForwardType a4) const {
 240     if (sink_.get())
 241       sink_->Run(
 242           internal::Forward(a1),
 243           internal::Forward(a2),
 244           internal::Forward(a3),
 245           internal::Forward(a4));
 246   }
 247
 248   bool is_null() const {
 249     return !sink_.get();
 250   }
 251
 252  private:
 253   template <typename Sink>
 254   struct Adapter : public Runnable {
 255     explicit Adapter(const Sink& sink) : sink(sink) {}
 256     virtual void Run(
 257         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 258         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 259         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 260         typename internal::Callback_ParamTraits<A4>::ForwardType a4) const
 261             MOJO_OVERRIDE {
 262       sink.Run(
 263           internal::Forward(a1),
 264           internal::Forward(a2),
 265           internal::Forward(a3),
 266           internal::Forward(a4));
 267     }
 268     Sink sink;
 269   };
 270
 271   internal::SharedPtr<Runnable> sink_;
 272 };
 273
 274 template <typename A1, typename A2, typename A3, typename A4, typename A5>
 275 class Callback<void(A1, A2, A3, A4, A5)> {
 276  public:
 277   struct Runnable {
 278     virtual ~Runnable() {}
 279     virtual void Run(
 280         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 281         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 282         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 283         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 284         typename internal::Callback_ParamTraits<A5>::ForwardType a5) const = 0;
 285   };
 286
 287   Callback() {}
 288
 289   // The Callback assumes ownership of |runnable|.
 290   explicit Callback(Runnable* runnable) : sink_(runnable) {}
 291
 292   // Any class that is copy-constructable and has a compatible Run method may
 293   // be adapted to a Callback using this constructor.
 294   template <typename Sink>
 295   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
 296
 297   void Run(
 298       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 299       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 300       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 301       typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 302       typename internal::Callback_ParamTraits<A5>::ForwardType a5) const {
 303     if (sink_.get())
 304       sink_->Run(
 305           internal::Forward(a1),
 306           internal::Forward(a2),
 307           internal::Forward(a3),
 308           internal::Forward(a4),
 309           internal::Forward(a5));
 310   }
 311
 312   bool is_null() const {
 313     return !sink_.get();
 314   }
 315
 316  private:
 317   template <typename Sink>
 318   struct Adapter : public Runnable {
 319     explicit Adapter(const Sink& sink) : sink(sink) {}
 320     virtual void Run(
 321         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 322         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 323         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 324         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 325         typename internal::Callback_ParamTraits<A5>::ForwardType a5) const
 326             MOJO_OVERRIDE {
 327       sink.Run(
 328           internal::Forward(a1),
 329           internal::Forward(a2),
 330           internal::Forward(a3),
 331           internal::Forward(a4),
 332           internal::Forward(a5));
 333     }
 334     Sink sink;
 335   };
 336
 337   internal::SharedPtr<Runnable> sink_;
 338 };
 339
 340 template <typename A1, typename A2, typename A3, typename A4, typename A5,
 341     typename A6>
 342 class Callback<void(A1, A2, A3, A4, A5, A6)> {
 343  public:
 344   struct Runnable {
 345     virtual ~Runnable() {}
 346     virtual void Run(
 347         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 348         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 349         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 350         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 351         typename internal::Callback_ParamTraits<A5>::ForwardType a5,
 352         typename internal::Callback_ParamTraits<A6>::ForwardType a6) const = 0;
 353   };
 354
 355   Callback() {}
 356
 357   // The Callback assumes ownership of |runnable|.
 358   explicit Callback(Runnable* runnable) : sink_(runnable) {}
 359
 360   // Any class that is copy-constructable and has a compatible Run method may
 361   // be adapted to a Callback using this constructor.
 362   template <typename Sink>
 363   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
 364
 365   void Run(
 366       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 367       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 368       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 369       typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 370       typename internal::Callback_ParamTraits<A5>::ForwardType a5,
 371       typename internal::Callback_ParamTraits<A6>::ForwardType a6) const {
 372     if (sink_.get())
 373       sink_->Run(
 374           internal::Forward(a1),
 375           internal::Forward(a2),
 376           internal::Forward(a3),
 377           internal::Forward(a4),
 378           internal::Forward(a5),
 379           internal::Forward(a6));
 380   }
 381
 382   bool is_null() const {
 383     return !sink_.get();
 384   }
 385
 386  private:
 387   template <typename Sink>
 388   struct Adapter : public Runnable {
 389     explicit Adapter(const Sink& sink) : sink(sink) {}
 390     virtual void Run(
 391         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 392         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 393         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 394         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 395         typename internal::Callback_ParamTraits<A5>::ForwardType a5,
 396         typename internal::Callback_ParamTraits<A6>::ForwardType a6) const
 397             MOJO_OVERRIDE {
 398       sink.Run(
 399           internal::Forward(a1),
 400           internal::Forward(a2),
 401           internal::Forward(a3),
 402           internal::Forward(a4),
 403           internal::Forward(a5),
 404           internal::Forward(a6));
 405     }
 406     Sink sink;
 407   };
 408
 409   internal::SharedPtr<Runnable> sink_;
 410 };
 411
 412 template <typename A1, typename A2, typename A3, typename A4, typename A5,
 413     typename A6, typename A7>
 414 class Callback<void(A1, A2, A3, A4, A5, A6, A7)> {
 415  public:
 416   struct Runnable {
 417     virtual ~Runnable() {}
 418     virtual void Run(
 419         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 420         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 421         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 422         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 423         typename internal::Callback_ParamTraits<A5>::ForwardType a5,
 424         typename internal::Callback_ParamTraits<A6>::ForwardType a6,
 425         typename internal::Callback_ParamTraits<A7>::ForwardType a7) const = 0;
 426   };
 427
 428   Callback() {}
 429
 430   // The Callback assumes ownership of |runnable|.
 431   explicit Callback(Runnable* runnable) : sink_(runnable) {}
 432
 433   // Any class that is copy-constructable and has a compatible Run method may
 434   // be adapted to a Callback using this constructor.
 435   template <typename Sink>
 436   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
 437
 438   void Run(
 439       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 440       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 441       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 442       typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 443       typename internal::Callback_ParamTraits<A5>::ForwardType a5,
 444       typename internal::Callback_ParamTraits<A6>::ForwardType a6,
 445       typename internal::Callback_ParamTraits<A7>::ForwardType a7) const {
 446     if (sink_.get())
 447       sink_->Run(
 448           internal::Forward(a1),
 449           internal::Forward(a2),
 450           internal::Forward(a3),
 451           internal::Forward(a4),
 452           internal::Forward(a5),
 453           internal::Forward(a6),
 454           internal::Forward(a7));
 455   }
 456
 457   bool is_null() const {
 458     return !sink_.get();
 459   }
 460
 461  private:
 462   template <typename Sink>
 463   struct Adapter : public Runnable {
 464     explicit Adapter(const Sink& sink) : sink(sink) {}
 465     virtual void Run(
 466         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
 467         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
 468         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
 469         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
 470         typename internal::Callback_ParamTraits<A5>::ForwardType a5,
 471         typename internal::Callback_ParamTraits<A6>::ForwardType a6,
 472         typename internal::Callback_ParamTraits<A7>::ForwardType a7) const
 473             MOJO_OVERRIDE {
 474       sink.Run(
 475           internal::Forward(a1),
 476           internal::Forward(a2),
 477           internal::Forward(a3),
 478           internal::Forward(a4),
 479           internal::Forward(a5),
 480           internal::Forward(a6),
 481           internal::Forward(a7));
 482     }
 483     Sink sink;
 484   };
 485
 486   internal::SharedPtr<Runnable> sink_;
 487 };
 488
 489 typedef Callback<void()> Closure;
 490
 491 }  // namespace mojo
 492
 493 #endif  // MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_