Home | History | Annotate | Download | only in bindings 
      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_
    494