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  private:
     47   template <typename Sink>
     48   struct Adapter : public Runnable {
     49     explicit Adapter(const Sink& sink) : sink(sink) {}
     50     virtual void Run() const MOJO_OVERRIDE {
     51       sink.Run();
     52     }
     53     Sink sink;
     54   };
     55 
     56   internal::SharedPtr<Runnable> sink_;
     57 };
     58 
     59 template <typename A1>
     60 class Callback<void(A1)> {
     61  public:
     62   struct Runnable {
     63     virtual ~Runnable() {}
     64     virtual void Run(
     65         typename internal::Callback_ParamTraits<A1>::ForwardType a1) const = 0;
     66   };
     67 
     68   Callback() {}
     69 
     70   // The Callback assumes ownership of |runnable|.
     71   explicit Callback(Runnable* runnable) : sink_(runnable) {}
     72 
     73   // Any class that is copy-constructable and has a compatible Run method may
     74   // be adapted to a Callback using this constructor.
     75   template <typename Sink>
     76   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
     77 
     78   void Run(
     79       typename internal::Callback_ParamTraits<A1>::ForwardType a1) const {
     80     if (sink_.get())
     81       sink_->Run(
     82           internal::Forward(a1));
     83   }
     84 
     85  private:
     86   template <typename Sink>
     87   struct Adapter : public Runnable {
     88     explicit Adapter(const Sink& sink) : sink(sink) {}
     89     virtual void Run(
     90         typename internal::Callback_ParamTraits<A1>::ForwardType a1) const
     91             MOJO_OVERRIDE {
     92       sink.Run(
     93           internal::Forward(a1));
     94     }
     95     Sink sink;
     96   };
     97 
     98   internal::SharedPtr<Runnable> sink_;
     99 };
    100 
    101 template <typename A1, typename A2>
    102 class Callback<void(A1, A2)> {
    103  public:
    104   struct Runnable {
    105     virtual ~Runnable() {}
    106     virtual void Run(
    107         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    108         typename internal::Callback_ParamTraits<A2>::ForwardType a2) const = 0;
    109   };
    110 
    111   Callback() {}
    112 
    113   // The Callback assumes ownership of |runnable|.
    114   explicit Callback(Runnable* runnable) : sink_(runnable) {}
    115 
    116   // Any class that is copy-constructable and has a compatible Run method may
    117   // be adapted to a Callback using this constructor.
    118   template <typename Sink>
    119   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
    120 
    121   void Run(
    122       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    123       typename internal::Callback_ParamTraits<A2>::ForwardType a2) const {
    124     if (sink_.get())
    125       sink_->Run(
    126           internal::Forward(a1),
    127           internal::Forward(a2));
    128   }
    129 
    130  private:
    131   template <typename Sink>
    132   struct Adapter : public Runnable {
    133     explicit Adapter(const Sink& sink) : sink(sink) {}
    134     virtual void Run(
    135         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    136         typename internal::Callback_ParamTraits<A2>::ForwardType a2) const
    137             MOJO_OVERRIDE {
    138       sink.Run(
    139           internal::Forward(a1),
    140           internal::Forward(a2));
    141     }
    142     Sink sink;
    143   };
    144 
    145   internal::SharedPtr<Runnable> sink_;
    146 };
    147 
    148 template <typename A1, typename A2, typename A3>
    149 class Callback<void(A1, A2, A3)> {
    150  public:
    151   struct Runnable {
    152     virtual ~Runnable() {}
    153     virtual void Run(
    154         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    155         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    156         typename internal::Callback_ParamTraits<A3>::ForwardType a3) const = 0;
    157   };
    158 
    159   Callback() {}
    160 
    161   // The Callback assumes ownership of |runnable|.
    162   explicit Callback(Runnable* runnable) : sink_(runnable) {}
    163 
    164   // Any class that is copy-constructable and has a compatible Run method may
    165   // be adapted to a Callback using this constructor.
    166   template <typename Sink>
    167   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
    168 
    169   void Run(
    170       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    171       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    172       typename internal::Callback_ParamTraits<A3>::ForwardType a3) const {
    173     if (sink_.get())
    174       sink_->Run(
    175           internal::Forward(a1),
    176           internal::Forward(a2),
    177           internal::Forward(a3));
    178   }
    179 
    180  private:
    181   template <typename Sink>
    182   struct Adapter : public Runnable {
    183     explicit Adapter(const Sink& sink) : sink(sink) {}
    184     virtual void Run(
    185         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    186         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    187         typename internal::Callback_ParamTraits<A3>::ForwardType a3) const
    188             MOJO_OVERRIDE {
    189       sink.Run(
    190           internal::Forward(a1),
    191           internal::Forward(a2),
    192           internal::Forward(a3));
    193     }
    194     Sink sink;
    195   };
    196 
    197   internal::SharedPtr<Runnable> sink_;
    198 };
    199 
    200 template <typename A1, typename A2, typename A3, typename A4>
    201 class Callback<void(A1, A2, A3, A4)> {
    202  public:
    203   struct Runnable {
    204     virtual ~Runnable() {}
    205     virtual void Run(
    206         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    207         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    208         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    209         typename internal::Callback_ParamTraits<A4>::ForwardType a4) const = 0;
    210   };
    211 
    212   Callback() {}
    213 
    214   // The Callback assumes ownership of |runnable|.
    215   explicit Callback(Runnable* runnable) : sink_(runnable) {}
    216 
    217   // Any class that is copy-constructable and has a compatible Run method may
    218   // be adapted to a Callback using this constructor.
    219   template <typename Sink>
    220   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
    221 
    222   void Run(
    223       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    224       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    225       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    226       typename internal::Callback_ParamTraits<A4>::ForwardType a4) const {
    227     if (sink_.get())
    228       sink_->Run(
    229           internal::Forward(a1),
    230           internal::Forward(a2),
    231           internal::Forward(a3),
    232           internal::Forward(a4));
    233   }
    234 
    235  private:
    236   template <typename Sink>
    237   struct Adapter : public Runnable {
    238     explicit Adapter(const Sink& sink) : sink(sink) {}
    239     virtual void Run(
    240         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    241         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    242         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    243         typename internal::Callback_ParamTraits<A4>::ForwardType a4) const
    244             MOJO_OVERRIDE {
    245       sink.Run(
    246           internal::Forward(a1),
    247           internal::Forward(a2),
    248           internal::Forward(a3),
    249           internal::Forward(a4));
    250     }
    251     Sink sink;
    252   };
    253 
    254   internal::SharedPtr<Runnable> sink_;
    255 };
    256 
    257 template <typename A1, typename A2, typename A3, typename A4, typename A5>
    258 class Callback<void(A1, A2, A3, A4, A5)> {
    259  public:
    260   struct Runnable {
    261     virtual ~Runnable() {}
    262     virtual void Run(
    263         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    264         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    265         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    266         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    267         typename internal::Callback_ParamTraits<A5>::ForwardType a5) const = 0;
    268   };
    269 
    270   Callback() {}
    271 
    272   // The Callback assumes ownership of |runnable|.
    273   explicit Callback(Runnable* runnable) : sink_(runnable) {}
    274 
    275   // Any class that is copy-constructable and has a compatible Run method may
    276   // be adapted to a Callback using this constructor.
    277   template <typename Sink>
    278   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
    279 
    280   void Run(
    281       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    282       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    283       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    284       typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    285       typename internal::Callback_ParamTraits<A5>::ForwardType a5) const {
    286     if (sink_.get())
    287       sink_->Run(
    288           internal::Forward(a1),
    289           internal::Forward(a2),
    290           internal::Forward(a3),
    291           internal::Forward(a4),
    292           internal::Forward(a5));
    293   }
    294 
    295  private:
    296   template <typename Sink>
    297   struct Adapter : public Runnable {
    298     explicit Adapter(const Sink& sink) : sink(sink) {}
    299     virtual void Run(
    300         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    301         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    302         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    303         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    304         typename internal::Callback_ParamTraits<A5>::ForwardType a5) const
    305             MOJO_OVERRIDE {
    306       sink.Run(
    307           internal::Forward(a1),
    308           internal::Forward(a2),
    309           internal::Forward(a3),
    310           internal::Forward(a4),
    311           internal::Forward(a5));
    312     }
    313     Sink sink;
    314   };
    315 
    316   internal::SharedPtr<Runnable> sink_;
    317 };
    318 
    319 template <typename A1, typename A2, typename A3, typename A4, typename A5,
    320     typename A6>
    321 class Callback<void(A1, A2, A3, A4, A5, A6)> {
    322  public:
    323   struct Runnable {
    324     virtual ~Runnable() {}
    325     virtual void Run(
    326         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    327         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    328         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    329         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    330         typename internal::Callback_ParamTraits<A5>::ForwardType a5,
    331         typename internal::Callback_ParamTraits<A6>::ForwardType a6) const = 0;
    332   };
    333 
    334   Callback() {}
    335 
    336   // The Callback assumes ownership of |runnable|.
    337   explicit Callback(Runnable* runnable) : sink_(runnable) {}
    338 
    339   // Any class that is copy-constructable and has a compatible Run method may
    340   // be adapted to a Callback using this constructor.
    341   template <typename Sink>
    342   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
    343 
    344   void Run(
    345       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    346       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    347       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    348       typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    349       typename internal::Callback_ParamTraits<A5>::ForwardType a5,
    350       typename internal::Callback_ParamTraits<A6>::ForwardType a6) const {
    351     if (sink_.get())
    352       sink_->Run(
    353           internal::Forward(a1),
    354           internal::Forward(a2),
    355           internal::Forward(a3),
    356           internal::Forward(a4),
    357           internal::Forward(a5),
    358           internal::Forward(a6));
    359   }
    360 
    361  private:
    362   template <typename Sink>
    363   struct Adapter : public Runnable {
    364     explicit Adapter(const Sink& sink) : sink(sink) {}
    365     virtual 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             MOJO_OVERRIDE {
    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     Sink sink;
    382   };
    383 
    384   internal::SharedPtr<Runnable> sink_;
    385 };
    386 
    387 template <typename A1, typename A2, typename A3, typename A4, typename A5,
    388     typename A6, typename A7>
    389 class Callback<void(A1, A2, A3, A4, A5, A6, A7)> {
    390  public:
    391   struct Runnable {
    392     virtual ~Runnable() {}
    393     virtual void Run(
    394         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    395         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    396         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    397         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    398         typename internal::Callback_ParamTraits<A5>::ForwardType a5,
    399         typename internal::Callback_ParamTraits<A6>::ForwardType a6,
    400         typename internal::Callback_ParamTraits<A7>::ForwardType a7) const = 0;
    401   };
    402 
    403   Callback() {}
    404 
    405   // The Callback assumes ownership of |runnable|.
    406   explicit Callback(Runnable* runnable) : sink_(runnable) {}
    407 
    408   // Any class that is copy-constructable and has a compatible Run method may
    409   // be adapted to a Callback using this constructor.
    410   template <typename Sink>
    411   Callback(const Sink& sink) : sink_(new Adapter<Sink>(sink)) {}
    412 
    413   void Run(
    414       typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    415       typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    416       typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    417       typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    418       typename internal::Callback_ParamTraits<A5>::ForwardType a5,
    419       typename internal::Callback_ParamTraits<A6>::ForwardType a6,
    420       typename internal::Callback_ParamTraits<A7>::ForwardType a7) const {
    421     if (sink_.get())
    422       sink_->Run(
    423           internal::Forward(a1),
    424           internal::Forward(a2),
    425           internal::Forward(a3),
    426           internal::Forward(a4),
    427           internal::Forward(a5),
    428           internal::Forward(a6),
    429           internal::Forward(a7));
    430   }
    431 
    432  private:
    433   template <typename Sink>
    434   struct Adapter : public Runnable {
    435     explicit Adapter(const Sink& sink) : sink(sink) {}
    436     virtual void Run(
    437         typename internal::Callback_ParamTraits<A1>::ForwardType a1,
    438         typename internal::Callback_ParamTraits<A2>::ForwardType a2,
    439         typename internal::Callback_ParamTraits<A3>::ForwardType a3,
    440         typename internal::Callback_ParamTraits<A4>::ForwardType a4,
    441         typename internal::Callback_ParamTraits<A5>::ForwardType a5,
    442         typename internal::Callback_ParamTraits<A6>::ForwardType a6,
    443         typename internal::Callback_ParamTraits<A7>::ForwardType a7) const
    444             MOJO_OVERRIDE {
    445       sink.Run(
    446           internal::Forward(a1),
    447           internal::Forward(a2),
    448           internal::Forward(a3),
    449           internal::Forward(a4),
    450           internal::Forward(a5),
    451           internal::Forward(a6),
    452           internal::Forward(a7));
    453     }
    454     Sink sink;
    455   };
    456 
    457   internal::SharedPtr<Runnable> sink_;
    458 };
    459 
    460 }  // namespace mojo
    461 
    462 #endif  // MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_
    463