libs/generic/callback.h

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #if !defined(INCLUDED_GENERIC_CLOSURE_H)
  23 #define INCLUDED_GENERIC_CLOSURE_H
  24
  25 /// \file
  26 /// \brief Type-safe techniques for binding the first argument of an opaque callback.
  27
  28 #include <cstddef>
  29 #include "functional.h"
  30 #include "callbackfwd.h"
  31
  32 template<typename Type>
  33 inline void* convertToOpaque(Type* t)
  34 {
  35   return t;
  36 }
  37 template<typename Type>
  38 inline void* convertToOpaque(const Type* t)
  39 {
  40   return const_cast<Type*>(t);
  41 }
  42 template<typename Type>
  43 inline void* convertToOpaque(Type& t)
  44 {
  45   return &t;
  46 }
  47 template<typename Type>
  48 inline void* convertToOpaque(const Type& t)
  49 {
  50   return const_cast<Type*>(&t);
  51 }
  52
  53
  54 template<typename Type>
  55 class ConvertFromOpaque
  56 {
  57 };
  58
  59 template<typename Type>
  60 class ConvertFromOpaque<Type&>
  61 {
  62 public:
  63   static Type& apply(void* p)
  64   {
  65     return *static_cast<Type*>(p);
  66   }
  67 };
  68
  69 template<typename Type>
  70 class ConvertFromOpaque<const Type&>
  71 {
  72 public:
  73   static const Type& apply(void* p)
  74   {
  75     return *static_cast<Type*>(p);
  76   }
  77 };
  78
  79
  80 template<typename Type>
  81 class ConvertFromOpaque<Type*>
  82 {
  83 public:
  84   static Type* apply(void* p)
  85   {
  86     return static_cast<Type*>(p);
  87   }
  88 };
  89
  90 template<typename Type>
  91 class ConvertFromOpaque<const Type*>
  92 {
  93 public:
  94   static const Type* apply(void* p)
  95   {
  96     return static_cast<Type*>(p);
  97   }
  98 };
  99
 100 template<typename Caller>
 101 class BindFirstOpaque
 102 {
 103   typedef typename Caller::first_argument_type FirstBound;
 104   FirstBound firstBound;
 105 public:
 106   typedef typename Caller::result_type result_type;
 107   explicit BindFirstOpaque(FirstBound firstBound) : firstBound(firstBound)
 108   {
 109   }
 110   result_type operator()() const
 111   {
 112     return Caller::call(firstBound);
 113   }
 114   FirstBound getBound() const
 115   {
 116     return firstBound;
 117   }
 118   static result_type thunk(void* environment)
 119   {
 120     return Caller::call(ConvertFromOpaque<FirstBound>::apply(environment));
 121   }
 122   void* getEnvironment() const
 123   {
 124     return convertToOpaque(firstBound);
 125   }
 126 };
 127
 128 template<typename Caller>
 129 class BindFirstOpaque1
 130 {
 131   typedef typename Caller::first_argument_type FirstBound;
 132   FirstBound firstBound;
 133 public:
 134   typedef typename Caller::second_argument_type first_argument_type;
 135   typedef typename Caller::result_type result_type;
 136   explicit BindFirstOpaque1(FirstBound firstBound) : firstBound(firstBound)
 137   {
 138   }
 139   result_type operator()(first_argument_type a1) const
 140   {
 141     return Caller::call(firstBound, a1);
 142   }
 143   FirstBound getBound() const
 144   {
 145     return firstBound;
 146   }
 147   static result_type thunk(void* environment, first_argument_type a1)
 148   {
 149     return Caller::call(ConvertFromOpaque<FirstBound>::apply(environment), a1);
 150   }
 151   void* getEnvironment() const
 152   {
 153     return convertToOpaque(firstBound);
 154   }
 155 };
 156
 157 template<typename Caller>
 158 class BindFirstOpaque2
 159 {
 160   typedef typename Caller::first_argument_type FirstBound;
 161   FirstBound firstBound;
 162 public:
 163   typedef typename Caller::second_argument_type first_argument_type;
 164   typedef typename Caller::third_argument_type second_argument_type;
 165   typedef typename Caller::result_type result_type;
 166   explicit BindFirstOpaque2(FirstBound firstBound) : firstBound(firstBound)
 167   {
 168   }
 169   result_type operator()(first_argument_type a1, second_argument_type a2) const
 170   {
 171     return Caller::call(firstBound, a1, a2);
 172   }
 173   FirstBound getBound() const
 174   {
 175     return firstBound;
 176   }
 177   static result_type thunk(void* environment, first_argument_type a1, second_argument_type a2)
 178   {
 179     return Caller::call(ConvertFromOpaque<FirstBound>::apply(environment), a1, a2);
 180   }
 181   void* getEnvironment() const
 182   {
 183     return convertToOpaque(firstBound);
 184   }
 185 };
 186
 187 template<typename Caller>
 188 class BindFirstOpaque3
 189 {
 190   typedef typename Caller::first_argument_type FirstBound;
 191   FirstBound firstBound;
 192 public:
 193   typedef typename Caller::second_argument_type first_argument_type;
 194   typedef typename Caller::third_argument_type second_argument_type;
 195   typedef typename Caller::fourth_argument_type third_argument_type;
 196   typedef typename Caller::result_type result_type;
 197   explicit BindFirstOpaque3(FirstBound firstBound) : firstBound(firstBound)
 198   {
 199   }
 200   result_type operator()(first_argument_type a1, second_argument_type a2, third_argument_type a3) const
 201   {
 202     return Caller::call(firstBound, a1, a2, a3);
 203   }
 204   FirstBound getBound() const
 205   {
 206     return firstBound;
 207   }
 208   static result_type thunk(void* environment, first_argument_type a1, second_argument_type a2, third_argument_type a3)
 209   {
 210     return Caller::call(ConvertFromOpaque<FirstBound>::apply(environment), a1, a2, a3);
 211   }
 212   void* getEnvironment() const
 213   {
 214     return convertToOpaque(firstBound);
 215   }
 216 };
 217
 218 template<typename Thunk_>
 219 class CallbackBase
 220 {
 221   void* m_environment;
 222   Thunk_ m_thunk;
 223 public:
 224   typedef Thunk_ Thunk;
 225   CallbackBase(void* environment, Thunk function) : m_environment(environment), m_thunk(function)
 226   {
 227   }
 228   void* getEnvironment() const
 229   {
 230     return m_environment;
 231   }
 232   Thunk getThunk() const
 233   {
 234     return m_thunk;
 235   }
 236 };
 237
 238 template<typename Thunk>
 239 inline bool operator==(const CallbackBase<Thunk>& self, const CallbackBase<Thunk>& other)
 240 {
 241   return self.getEnvironment() == other.getEnvironment() && self.getThunk() == other.getThunk();
 242 }
 243 template<typename Thunk>
 244 inline bool operator!=(const CallbackBase<Thunk>& self, const CallbackBase<Thunk>& other)
 245 {
 246   return !(self == other);
 247 }
 248 template<typename Thunk>
 249 inline bool operator<(const CallbackBase<Thunk>& self, const CallbackBase<Thunk>& other)
 250 {
 251   return self.getEnvironment() < other.getEnvironment() ||
 252         (!(other.getEnvironment() < self.getEnvironment()) && self.getThunk() < other.getThunk());
 253 }
 254
 255
 256 /// \brief Combines a void pointer with a pointer to a function which operates on a void pointer.
 257 ///
 258 /// Use with the callback constructors MemberCaller, ConstMemberCaller, ReferenceCaller, ConstReferenceCaller, PointerCaller, ConstPointerCaller and FreeCaller.
 259 template<typename Result>
 260 class Callback0 : public CallbackBase<Result (*)(void*)>
 261 {
 262   typedef CallbackBase<Result (*)(void*)> Base;
 263   static Result nullThunk(void*)
 264   {
 265   }
 266
 267 public:
 268   typedef Result result_type;
 269
 270   Callback0() : Base(0, nullThunk)
 271   {
 272   }
 273   template<typename Caller>
 274   Callback0(const BindFirstOpaque<Caller>& caller) : Base(caller.getEnvironment(), BindFirstOpaque<Caller>::thunk)
 275   {
 276   }
 277   Callback0(void* environment, Thunk function) : Base(environment, function)
 278   {
 279   }
 280   result_type operator()() const
 281   {
 282     return getThunk()(getEnvironment());
 283   }
 284 };
 285
 286 template<typename Caller>
 287 inline Callback0<typename Caller::result_type> makeCallback0(const Caller& caller, typename Caller::first_argument_type callee)
 288 {
 289   return Callback0<typename Caller::result_type>(BindFirstOpaque<Caller>(callee));
 290 }
 291 template<typename Caller>
 292 inline Callback0<typename Caller::result_type> makeStatelessCallback0(const Caller& caller)
 293 {
 294   return makeCallback0(Caller0To1<Caller>(), 0);
 295 }
 296
 297 typedef Callback0<void> Callback;
 298
 299
 300
 301 /// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and one other argument.
 302 ///
 303 /// Use with the callback constructors MemberCaller1, ConstMemberCaller1, ReferenceCaller1, ConstReferenceCaller1, PointerCaller1, ConstPointerCaller1 and FreeCaller1.
 304 template<typename FirstArgument, typename Result>
 305 class Callback1 : public CallbackBase<Result (*)(void*, FirstArgument)>
 306 {
 307   typedef CallbackBase<Result (*)(void*, FirstArgument)> Base;
 308   static Result nullThunk(void*, FirstArgument)
 309   {
 310   }
 311
 312 public:
 313   typedef FirstArgument first_argument_type;
 314   typedef Result result_type;
 315
 316   Callback1() : Base(0, nullThunk)
 317   {
 318   }
 319   template<typename Caller>
 320   Callback1(const BindFirstOpaque1<Caller>& caller) : Base(caller.getEnvironment(), BindFirstOpaque1<Caller>::thunk)
 321   {
 322   }
 323   Callback1(void* environment, Thunk function) : Base(environment, function)
 324   {
 325   }
 326   result_type operator()(FirstArgument firstArgument) const
 327   {
 328     return getThunk()(getEnvironment(), firstArgument);
 329   }
 330 };
 331
 332 template<typename Caller>
 333 inline Callback1<typename Caller::second_argument_type, typename Caller::result_type> makeCallback1(const Caller& caller, typename Caller::first_argument_type callee)
 334 {
 335   return Callback1<typename Caller::second_argument_type, typename Caller::result_type>(BindFirstOpaque1<Caller>(callee));
 336 }
 337 template<typename Caller>
 338 inline Callback1<typename Caller::second_argument_type, typename Caller::result_type> makeStatelessCallback1(const Caller& caller)
 339 {
 340   return makeCallback1(Caller1To2<Caller>(), 0);
 341 }
 342
 343
 344 /// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and two other arguments.
 345 ///
 346 template<typename FirstArgument, typename SecondArgument, typename Result>
 347 class Callback2 : public CallbackBase<Result (*)(void*, FirstArgument, SecondArgument)>
 348 {
 349   typedef CallbackBase<Result (*)(void*, FirstArgument, SecondArgument)> Base;
 350   static Result nullThunk(void*, FirstArgument, SecondArgument)
 351   {
 352   }
 353
 354 public:
 355   typedef FirstArgument first_argument_type;
 356   typedef SecondArgument second_argument_type;
 357   typedef Result result_type;
 358
 359   Callback2() : Base(0, nullThunk)
 360   {
 361   }
 362   template<typename Caller>
 363   Callback2(const BindFirstOpaque2<Caller>& caller) : Base(caller.getEnvironment(), BindFirstOpaque2<Caller>::thunk)
 364   {
 365   }
 366   Callback2(void* environment, Thunk function) : Base(environment, function)
 367   {
 368   }
 369   result_type operator()(FirstArgument firstArgument, SecondArgument secondArgument) const
 370   {
 371     return getThunk()(getEnvironment(), firstArgument, secondArgument);
 372   }
 373 };
 374
 375 template<typename Caller>
 376 inline Callback2<
 377   typename Caller::second_argument_type,
 378   typename Caller::third_argument_type,
 379   typename Caller::result_type
 380 > makeCallback2(const Caller& caller, typename Caller::first_argument_type callee)
 381 {
 382   return Callback2<
 383     typename Caller::second_argument_type,
 384     typename Caller::third_argument_type,
 385     typename Caller::result_type
 386   >(BindFirstOpaque2<Caller>(callee));
 387 }
 388 template<typename Caller>
 389 inline Callback2<
 390   typename Caller::first_argument_type,
 391   typename Caller::second_argument_type,
 392   typename Caller::result_type
 393 > makeStatelessCallback2(const Caller& caller)
 394 {
 395   return makeCallback2(Caller2To3<Caller>(), 0);
 396 }
 397
 398
 399 /// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and three other arguments.
 400 ///
 401 template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename Result>
 402 class Callback3 : public CallbackBase<Result (*)(void*, FirstArgument, SecondArgument, ThirdArgument)>
 403 {
 404   typedef CallbackBase<Result (*)(void*, FirstArgument, SecondArgument, ThirdArgument)> Base;
 405   static Result nullThunk(void*, FirstArgument, SecondArgument, ThirdArgument)
 406   {
 407   }
 408
 409 public:
 410   typedef FirstArgument first_argument_type;
 411   typedef SecondArgument second_argument_type;
 412   typedef ThirdArgument third_argument_type;
 413   typedef Result result_type;
 414
 415   Callback3() : Base(0, nullThunk)
 416   {
 417   }
 418   template<typename Caller>
 419   Callback3(const BindFirstOpaque3<Caller>& caller) : Base(caller.getEnvironment(), BindFirstOpaque3<Caller>::thunk)
 420   {
 421   }
 422   Callback3(void* environment, Thunk function) : Base(environment, function)
 423   {
 424   }
 425   result_type operator()(FirstArgument firstArgument, SecondArgument secondArgument, ThirdArgument thirdArgument) const
 426   {
 427     return getThunk()(getEnvironment(), firstArgument, secondArgument, thirdArgument);
 428   }
 429 };
 430
 431 template<typename Caller>
 432 inline Callback3<
 433   typename Caller::second_argument_type,
 434   typename Caller::third_argument_type,
 435   typename Caller::fourth_argument_type,
 436   typename Caller::result_type
 437 > makeCallback3(const Caller& caller, typename Caller::first_argument_type callee)
 438 {
 439   return Callback3<
 440     typename Caller::second_argument_type,
 441     typename Caller::third_argument_type,
 442     typename Caller::fourth_argument_type,
 443     typename Caller::result_type
 444   >(BindFirstOpaque3<Caller>(callee));
 445 }
 446 template<typename Caller>
 447 inline Callback3<
 448   typename Caller::first_argument_type,
 449   typename Caller::second_argument_type,
 450   typename Caller::third_argument_type,
 451   typename Caller::result_type
 452 > makeStatelessCallback3(const Caller& caller)
 453 {
 454   return makeCallback3(Caller3To4<Caller>(), 0);
 455 }
 456
 457
 458 /// \brief Forms a Callback from a non-const Environment reference and a non-const Environment member-function.
 459 ///
 460 /// \dontinclude generic/callback.cpp
 461 /// \skipline MemberCaller example
 462 /// \until end example
 463 template<typename Environment, void (Environment::*member)()>
 464 class MemberCaller : public BindFirstOpaque< Member<Environment, void, member> >
 465 {
 466 public:
 467   MemberCaller(Environment& environment) : BindFirstOpaque< Member<Environment, void, member> >(environment)
 468   {
 469   }
 470 };
 471
 472 /// \brief Forms a Callback from a const Environment reference and a const Environment member-function.
 473 ///
 474 /// \dontinclude generic/callback.cpp
 475 /// \skipline MemberCaller example
 476 /// \until end example
 477 template<typename Environment, void (Environment::*member)() const>
 478 class ConstMemberCaller : public BindFirstOpaque< ConstMember<Environment, void, member> >
 479 {
 480 public:
 481   ConstMemberCaller(const Environment& environment) : BindFirstOpaque< ConstMember<Environment, void, member> >(environment)
 482   {
 483   }
 484 };
 485
 486 /// \brief Forms a Callback from a non-const Environment reference and a const Environment member-function which takes one argument.
 487 template<typename Environment, typename FirstArgument, void (Environment::*member)(FirstArgument)>
 488 class MemberCaller1 : public BindFirstOpaque1< Member1<Environment, FirstArgument, void, member> >
 489 {
 490 public:
 491   MemberCaller1(Environment& environment) : BindFirstOpaque1< Member1<Environment, FirstArgument, void, member> >(environment)
 492   {
 493   }
 494 };
 495
 496 /// \brief Forms a Callback from a const Environment reference and a const Environment member-function which takes one argument.
 497 template<typename Environment, typename FirstArgument, void (Environment::*member)(FirstArgument) const>
 498 class ConstMemberCaller1 : public BindFirstOpaque1< ConstMember1<Environment, FirstArgument, void, member> >
 499 {
 500 public:
 501   ConstMemberCaller1(const Environment& environment) : BindFirstOpaque1< ConstMember1<Environment, FirstArgument, void, member> >(environment)
 502   {
 503   }
 504 };
 505
 506 /// \brief Forms a Callback from a non-const Environment reference and a free function which operates on a non-const Environment reference.
 507 ///
 508 /// \dontinclude generic/callback.cpp
 509 /// \skipline ReferenceCaller example
 510 /// \until end example
 511 template<typename Environment, void (*func)(Environment&)>
 512 class ReferenceCaller : public BindFirstOpaque< Function1<Environment&, void, func> >
 513 {
 514 public:
 515   ReferenceCaller(Environment& environment) : BindFirstOpaque< Function1<Environment&, void, func> >(environment)
 516   {
 517   }
 518 };
 519
 520 /// \brief Forms a Callback from a const Environment reference and a free function which operates on a const Environment reference.
 521 ///
 522 /// \dontinclude generic/callback.cpp
 523 /// \skipline ReferenceCaller example
 524 /// \until end example
 525 template<typename Environment, void (*func)(const Environment&)>
 526 class ConstReferenceCaller : public BindFirstOpaque< Function1<const Environment&, void, func> >
 527 {
 528 public:
 529   ConstReferenceCaller(const Environment& environment) : BindFirstOpaque< Function1<const Environment&, void, func> >(environment)
 530   {
 531   }
 532 };
 533
 534 /// \brief Forms a Callback from a non-const Environment reference and a free function which operates on a non-const Environment reference and one other argument.
 535 template<typename Environment, typename FirstArgument, void (*func)(Environment&, FirstArgument)>
 536 class ReferenceCaller1 : public BindFirstOpaque1< Function2<Environment&, FirstArgument, void, func> >
 537 {
 538 public:
 539   ReferenceCaller1(Environment& environment) : BindFirstOpaque1< Function2<Environment&, FirstArgument, void, func> >(environment)
 540   {
 541   }
 542 };
 543
 544 /// \brief Forms a Callback from a const Environment reference and a free function which operates on a const Environment reference and one other argument.
 545 template<typename Environment, typename FirstArgument, void (*func)(const Environment&, FirstArgument)>
 546 class ConstReferenceCaller1 : public BindFirstOpaque1< Function2<const Environment&, FirstArgument, void, func> >
 547 {
 548 public:
 549   ConstReferenceCaller1(const Environment& environment) : BindFirstOpaque1< Function2<const Environment&, FirstArgument, void, func> >(environment)
 550   {
 551   }
 552 };
 553
 554 /// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer.
 555 template<typename Environment, void (*func)(Environment*)>
 556 class PointerCaller : public BindFirstOpaque< Function1<Environment*, void, func> >
 557 {
 558 public:
 559   PointerCaller(Environment* environment) : BindFirstOpaque< Function1<Environment*, void, func> >(environment)
 560   {
 561   }
 562 };
 563
 564 /// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer.
 565 template<typename Environment, void (*func)(const Environment*)>
 566 class ConstPointerCaller : public BindFirstOpaque< Function1<const Environment*, void, func> >
 567 {
 568 public:
 569   ConstPointerCaller(const Environment* environment) : BindFirstOpaque< Function1<const Environment*, void, func> >(environment)
 570   {
 571   }
 572 };
 573
 574 /// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer and one other argument.
 575 template<typename Environment, typename FirstArgument, void (*func)(Environment*, FirstArgument)>
 576 class PointerCaller1 : public BindFirstOpaque1< Function2<Environment*, FirstArgument, void, func> >
 577 {
 578 public:
 579   PointerCaller1(Environment* environment) : BindFirstOpaque1< Function2<Environment*, FirstArgument, void, func> >(environment)
 580   {
 581   }
 582 };
 583
 584 /// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer and one other argument.
 585 template<typename Environment, typename FirstArgument, void (*func)(const Environment*, FirstArgument)>
 586 class ConstPointerCaller1 : public BindFirstOpaque1< Function2<const Environment*, FirstArgument, void, func> >
 587 {
 588 public:
 589   ConstPointerCaller1(const Environment* environment) : BindFirstOpaque1< Function2<const Environment*, FirstArgument, void, func> >(environment)
 590   {
 591   }
 592 };
 593
 594 /// \brief Forms a Callback from a free function which takes no arguments.
 595 template<void (*func)()>
 596 class FreeCaller : public BindFirstOpaque< Caller0To1< Function0<void, func> > >
 597 {
 598 public:
 599   FreeCaller() : BindFirstOpaque< Caller0To1< Function0<void, func> > >(0)
 600   {
 601   }
 602 };
 603
 604 /// \brief Forms a Callback from a free function which takes a single argument.
 605 template<typename FirstArgument, void (*func)(FirstArgument)>
 606 class FreeCaller1 : public BindFirstOpaque1< Caller1To2< Function1<FirstArgument, void, func> > >
 607 {
 608 public:
 609   FreeCaller1() : BindFirstOpaque1< Caller1To2< Function1<FirstArgument, void, func> > >(0)
 610   {
 611   }
 612 };
 613
 614
 615 /// \brief Constructs a Callback from a non-const \p functor with zero arguments.
 616 ///
 617 /// \param Functor Must define \c operator()().
 618 template<typename Functor>
 619 inline Callback makeCallback(Functor& functor)
 620 {
 621   return Callback(MemberCaller<Functor, &Functor::operator()>(functor));
 622 }
 623
 624 /// \brief  Constructs a Callback from a const \p functor with zero arguments.
 625 ///
 626 /// \param Functor Must define const \c operator()().
 627 template<typename Functor>
 628 inline Callback makeCallback(const Functor& functor)
 629 {
 630   return Callback(ConstMemberCaller<Functor, &Functor::operator()>(functor));
 631 }
 632
 633 /// \brief  Constructs a Callback1 from a non-const \p functor with one argument.
 634 ///
 635 /// \param Functor Must define \c first_argument_type and \c operator()(first_argument_type).
 636 template<typename Functor>
 637 inline Callback1<typename Functor::first_argument_type> makeCallback1(Functor& functor)
 638 {
 639   typedef typename Functor::first_argument_type FirstArgument;
 640   return Callback1<FirstArgument>(MemberCaller1<Functor, FirstArgument, &Functor::operator()>(functor));
 641 }
 642
 643 /// \brief  Constructs a Callback1 from a const \p functor with one argument.
 644 ///
 645 /// \param Functor Must define \c first_argument_type and const \c operator()(first_argument_type).
 646 template<typename Functor>
 647 inline Callback1<typename Functor::first_argument_type> makeCallback1(const Functor& functor)
 648 {
 649   typedef typename Functor::first_argument_type FirstArgument;
 650   return Callback1<FirstArgument>(ConstMemberCaller1<Functor, FirstArgument, &Functor::operator()>(functor));
 651 }
 652
 653
 654 typedef Callback1<bool> BoolImportCallback;
 655 typedef Callback1<const BoolImportCallback&> BoolExportCallback;
 656
 657 typedef Callback1<int> IntImportCallback;
 658 typedef Callback1<const IntImportCallback&> IntExportCallback;
 659
 660 typedef Callback1<float> FloatImportCallback;
 661 typedef Callback1<const FloatImportCallback&> FloatExportCallback;
 662
 663 typedef Callback1<const char*> StringImportCallback;
 664 typedef Callback1<const StringImportCallback&> StringExportCallback;
 665
 666 typedef Callback1<std::size_t> SizeImportCallback;
 667 typedef Callback1<const SizeImportCallback&> SizeExportCallback;
 668
 669
 670 #endif