callback.h

Go to the documentation of this file.

/* Copyright (C) 2008 to 2014 Chris Vine
 
The library comprised in this file or of which this file is part is
distributed by Chris Vine under the GNU Lesser General Public
License as follows:
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1 of
   the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License, version 2.1, for more details.
 
   You should have received a copy of the GNU Lesser General Public
   License, version 2.1, along with this library (see the file LGPL.TXT
   which came with this source code package in the c++-gtk-utils
   sub-directory); if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
However, it is not intended that the object code of a program whose
source code instantiates a template from this file or uses macros or
inline functions (of any length) should by reason only of that
instantiation or use be subject to the restrictions of use in the GNU
Lesser General Public License.  With that in mind, the words "and
macros, inline functions and instantiations of templates (of any
length)" shall be treated as substituted for the words "and small
macros and small inline functions (ten lines or less in length)" in
the fourth paragraph of section 5 of that licence.  This does not
affect any other reason why object code may be subject to the
restrictions in that licence (nor for the avoidance of doubt does it
affect the application of section 2 of that licence to modifications
of the source code in this file).
 
*/
 
#ifndef CGU_CALLBACK_H
#define CGU_CALLBACK_H
 
/**
 * @file callback.h
 * @brief This file provides classes encapsulating callbacks.
 *
 * \#include <c++-gtk-utils/callback.h>
 *
 * These classes encapsulate callbacks (they are closures).  They
 * comprise a generic callback creation and execution interface.
 * There is a basic Callback::Callback type, which is an entire
 * closure or 'thunk', where all the arguments are bound in the
 * constructor and is completely opaque.  Callback::CallbackArg<T> is
 * a class which takes one unbound argument of type T when the
 * callback is dispatched, with any other arguments being bound at
 * construction time.  (The opaque Callback::Callback type is in fact
 * just a typedef for Callback::CallbackArg<void>: the two types are
 * interchangeable.)  In addition, from version 1.2.10 of the library,
 * by default a callback can be executed by a Callback::CallbackArg<T>
 * object with two or three unbound arguments by providing a
 * Cgu::TypeTuple struct as the template type: see under "Usage" below
 * and @ref TypeTuple for further information.
 *
 * The classes can represent static and non-static member functions
 * and plain functions.  In the case of a non-static member function,
 * the object whose member function the callback represents must
 * remain in existence until any invocations of the callback have
 * completed.  The function referred to must be one of void return
 * type.
 *
 * The clases are particularly relevant where a callback object may
 * need to be handed between threads, or in other cases where a
 * callback object has to be passed by pointer (which will happen at
 * some stage with glib or pthreads).  They are therefore useful for
 * general event passing when used together with the Callback::post()
 * functions, or as the data argument of a call to
 * g_signal_connect_data() in a case where a better design arises when
 * passing arguments known at connect time by storing them in the
 * callback object itself, or as the continuation for GIO async
 * operations.
 *
 * The classes are also used in the Emitter/EmitterArg classes in
 * emitter.h, which enable callbacks to be connected to an emitter and
 * provide for automatic disconnection where a class object whose
 * member a callback represents ceases to exist.
 *
 * The Callback::make() functions
 * ------------------------------
 *
 * The templated helper Callback::make() functions make it trivial to
 * create a callback object of the correct type.  A maximum of two
 * bound arguments to pass to the relevant function or class method is
 * provided for and from version 1.2.10 a maximum of three unbound
 * arguments to pass at call time - but this can be extended
 * indefinitely (prior to version 1.2.10 only one unbound argument was
 * provided for).  If there are unbound arguments, they must be the
 * last (trailing) arguments of the relevant function or method to be
 * called.  Callback/CallbackArg classes do not provide for a return
 * value.  If a result is wanted, users should pass an unbound
 * argument by reference or pointer (or pointer to pointer).
 *
 * Although as mentioned above only two bound and three unbound
 * arguments are provided for, as any of those arguments can be a
 * struct, any number of arguments can be passed as members of a
 * struct (or, in C++11, a std::tuple).
 *
 * The Callback::make() functions do a direct type mapping from the
 * bound arguments of the function or method represented by the
 * callback object to the arguments stored by the callback object.
 * Bound value arguments of the relevant function or method to be
 * called are therefore stored by value in the callback object.  A
 * bound argument can comprise a reference argument (T& or const T&)
 * if the template parameters of the Callback::make() call are
 * qualified by hand to avoid a type mismatch: see under "Usage" below
 * for further particulars, and if the reference argument is non-const
 * this allows the referenced argument to be mutated.  However as this
 * would result in the lifetime of the argument not being controlled
 * by the callback object (it would not keep its own copy), it will
 * often be unsafe to do so.  (The documentation on
 * Thread::JoinableHandle gives a usage where where binding a
 * reference argument would be safe.)
 *
 * From version 1.2.13, the library also provides Callback::make_ref()
 * functions, which force the callback object to keep a copy of the
 * value passed where a target function argument is a const reference.
 * It is therefore safe with const reference arguments.  No explicit
 * type qualification is required by Callback::make_ref().  In
 * addition the Callback::make_ref() functions provide for more
 * efficient passing of class type bound arguments than does
 * Callback::make(): see further below.
 *
 * Where more than one unbound argument is to be passed to the target
 * function, the Cgu::TypeTuple type container struct is used - see
 * under Usage below for examples.
 *
 * The Callback::make_ref() functions
 * ----------------------------------
 *
 * In order to enable the widest variety of types to be accepted as
 * arguments (including mutating non-const reference arguments in
 * those cases where it is safe, and also string literals), as
 * mentioned above when constructing a callback object
 * Callback::make() receives non-reference bound arguments by value,
 * and if unoptimised these may be copied up to two times, and once
 * more when the target function is dispatched.  Where a bound
 * argument is a pointer or a fundamental type (an integral or
 * floating-point type), optimization by copy elision will reduce the
 * number of times argument copying takes place when constructing a
 * callback object to once, but the standard does not permit that with
 * class types where the constructor or destructor have side effects
 * or it cannot be ascertained whether they have side effects.
 *
 * Therefore, to cater for cases where a target function takes a class
 * type argument by const reference or value, from version 1.2.13 the
 * Callback::make_ref() functions are provided.  Unlike
 * Callback::make(), when constructing a callback for a target
 * function taking a const reference bound argument,
 * Callback::make_ref() will force the callback object to keep a copy
 * of the argument instead of a reference to that argument.  This
 * makes the use of const reference arguments safe (at the cost of the
 * taking of that copy).  It cannot be used with non-const references.
 * In addition, Callback::make_ref() automatically passes class type
 * arguments for storage by the callback object by reference to const,
 * so reducing the number of times they are copied, when stored, to
 * once.
 *
 * In the case of a value argument, at callback dispatch time one
 * additional copy will be made in the normal way when the target
 * function is called, but in the case of a const reference argument
 * no such additional copy will be made.  What all this means is that,
 * where bound arguments include a non-trivial class type, the most
 * efficient and exception safe strategy is usually to construct the
 * object of the class type on free store and held by Cgu::SharedPtr
 * or Cgu::SharedLockPtr, have the target function take it by const
 * Cgu::SharedPtr& or const Cgu::SharedLockPtr&, and construct the
 * callback object using Callback::make_ref().
 *
 * This flexibility of Callback::make_ref() has a downside: unlike
 * Callback::make(), Callback::make_ref() cannot resolve overloaded
 * functions by argument type.  Where a function has two or more
 * overloads taking the same number of arguments, explicit
 * disambiguation by the user is required (see further below under
 * Overloaded Functions).
 *
 * Summary: If a callback object's bound arguments are all simple
 * fundamental types such as pointers (including C strings), integers
 * or floating points, use Callback::make().  Where bound arguments
 * include class types, use Callback::make_ref().
 *
 * The Callback::make_val() functions
 * ----------------------------------
 *
 * The library also provides Callback::make_val() functions.  These
 * are retained to keep code compatibility with earlier versions of
 * the library.  They were optimised for use where a target function
 * takes bound arguments of class type by value, but are now
 * deprecated and superseded by the automatic variable type mapping of
 * Callback::make_ref().  Callback::make_ref() should now be used
 * instead of Callback::make_val().
 *
 * Functors
 * --------
 *
 * If a functor class of void return type is required (say for passing
 * to a c++ algorithm or container, or for automatic lifetime
 * management of the Callback object), the Callback::Functor and
 * Callback::FunctorArg wrapper classes can be used.  However, for
 * many c++ algorithms where anonymous functors created as temporaries
 * can be used, the std::ptr_fun() and MemFun::make() factory
 * functions will be a more obvious choice.
 *
 * Callback::SafeFunctor and Callback::SafeFunctorArg classes are the
 * same as Callback::Functor and Callback::FunctorArg classes, except
 * that objects of the safe version may be passed and copied between
 * threads and put in different containers in different threads (that
 * is, the reference count maintained with respect to the contained
 * callback object is thread-safe).  They use a SharedLockPtr object
 * to hold the referenced callback object.
 *
 * Memory allocation
 * -----------------
 *
 * If the library is installed using the
 * \--with-glib-memory-slices-compat or
 * \--with-glib-memory-slices-no-compat configuration options, any
 * Callback::Functor, Callback::FunctorArg, Callback::SafeFunctor or
 * Callback::SafeFunctorArg objects constructed on free store (usually
 * they won't be) will be constructed in glib memory slices.  A
 * contained Callback::Callback or Callback::CallbackArg object, which
 * will always be constructed on free store, will be constructed in
 * glib memory slices if the \--with-glib-memory-slices-no-compat
 * configuration option is chosen.
 *
 * Usage
 * -----
 *
 * For a class object my_obj of type MyClass, with a method void
 * MyClass::my_method(int, const char*), usage for a fully bound
 * callback or functor would be:
 *
 * @code 
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::Callback* cb =
 *     Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n");
 *   cb->dispatch();
 *   delete cb;
 *
 *   Callback::Functor f(Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n"));
 *   f();
 * @endcode
 *
 * Or for a partially bound callback or functor:
 *
 * @code
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::CallbackArg<const char*>* cb =
 *     Callback::make(my_obj, &MyClass::my_method, arg);
 *   cb->dispatch("Hello\n");
 *   delete cb;
 *
 *   Callback::FunctorArg<const char*> f(Callback::make(my_obj, &MyClass::my_method, arg));
 *   f("Hello\n");
 * @endcode
 *
 * To provide for two or three unbound arguments, from version 1.2.10
 * of the library the Cgu::TypeTuple struct is used (this struct has
 * no members and is never instantiated, so it does not impose any
 * overhead: see @ref TypeTuple for further information).  As in the
 * case of a single unbound argument, if there are bound arguments
 * these multiple unbound arguments must be the last (trailing)
 * arguments of the function to be called.  For a class object my_obj
 * of type MyClass, with a method void MyClass::my_method2(int, int,
 * int, const char*), usage with two unbound arguments would be:
 *
 * @code 
 *   int arg1 = 1, arg2 = 2, arg3 = 3;
 *   Cgu::Callback::CallbackArg<Cgu::TypeTuple<int, const char*> >* cb =
 *     Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1, arg2);
 *   cb->dispatch(arg3, "Hello\n");
 *   delete cb;
 *
 *   Cgu::Callback::FunctorArg<Cgu::TypeTuple<int, const char*> > f(Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1, arg2));
 *   f(arg3, "Hello\n");
 * @endcode
 *
 * and for three unbound arguments:
 *
 * @code 
 *   int arg1 = 1, arg2 = 2, arg3 = 3;
 *   Cgu::Callback::CallbackArg<Cgu::TypeTuple<int, int, const char*> >* cb =
 *     Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1);
 *   cb->dispatch(arg2, arg3, "Hello\n");
 *   delete cb;
 *
 *   Cgu::Callback::FunctorArg<Cgu::TypeTuple<int, int, const char*> > f(Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1));
 *   f(arg2, arg3, "Hello\n");
 * @endcode
 *
 * The syntax for the construction of a callback object representing a
 * static member function with a signature void MyClass::my_func(int,
 * const char*), or for a normal function, is similar to the
 * non-static member function case, except that the call to
 * Callback::make would comprise:
 *
 * @code
 *   Callback::make(&MyClass::my_func, arg, "Hello\n");
 * @endcode
 * (fully bound), or
 * @code
 *   Callback::make(&MyClass::my_func, arg);
 * @endcode
 * (partially bound), and so on.
 *
 * To bind to reference arguments, the call to Callback::make() must
 * be explicitly typed.  For a class object my_obj of type MyClass,
 * with a method void MyClass::my_method(int&), usage for a fully
 * bound callback or functor would be:
 *
 * @code
 *   int arg = 1;
 *   Callback::Callback* cb =
 *     Callback::make<MyClass, int&>(my_obj, &MyClass::my_method, arg);
 * @endcode
 *
 * Note however the caveats above about binding to reference
 * arguments.
 *
 * No similar explicit typing is required by Callback::make_ref().
 * Thus for a class object my_obj of type MyClass, with a method void
 * MyClass::my_method(int, const Something&), usage for a fully bound
 * callback or functor would be:
 *
 * @code
 *   int arg1 = 1;
 *   Something arg2;
 *   Callback::Callback* cb =
 *     Callback::make_ref(my_obj, &MyClass::my_method, arg1, arg2);
 * @endcode
 *
 * Overloaded functions
 * --------------------
 *
 * Note that creating callbacks for overloaded functions can give rise
 * to an ambiguity when using Callback::make(), arising from the fact
 * that the callback object may have an unbound argument.  For
 * example:
 *
 * @code
 *   class MyClass {
 *     ...
 *     void add(int i);
 *     void add(int i, int j);
 *     void add(double d);
 *   };
 *   MyClass obj;
 *   using namespace Cgu;
 *   Callback::Callback* cb1 = Callback::make(obj, &MyClass::add, 1, 2); // ok
 *   Callback::Callback* cb2 = Callback::make(obj, &MyClass::add, 1.0);  // ok
 *   Callback::Callback* cb3 = Callback::make(obj, &MyClass::add, 1);    // ambiguous - compilation failure
 * @endcode
 *
 * The third call to Callback::make() is ambiguous, as it could be
 * creating a callback for either the function MyClass::add(int) with
 * no unbound argument (that is, creating a Callback::Callback
 * object), or the function MyClass::add(int, int) with an unbound int
 * argument (that is, creating a Callback::CallbackArg<int> object).
 * This situation could be disambiguated by specifically stating the
 * type of the function which is to be chosen, namely, to instantiate
 * the callback in the third call with:
 *
 * @code
 *   // either:
 *   Callback::Callback* cb3 =
 *     Callback::make(obj, static_cast<void (MyClass::*)(int)>(&MyClass::add), 1);
 *   // or:
 *   Callback::CallbackArg<int>* cb3 =
 *     Callback::make(obj, static_cast<void (MyClass::*)(int, int)>(&MyClass::add), 1);
 * @endcode
 *
 * Callback::make_ref() is less capable than Callback::make() at
 * deducing template types.  It cannot resolve overloaded functions by
 * examining the arguments passed to it.  For example, take a class
 * MyClass as follows:
 *
 * @code
 *   class MyClass {
 *     ...
 *     void add(int i, const double& d);
 *     void add(const int& j, const int& k);
 *   };
 * @endcode
 *
 * Callback::make_ref() would require explicit disambiguation like
 * this:
 *
 * @code
 *   Callback::Callback* cb1 =
 *     Callback::make_ref(obj, static_cast<void (MyClass::*)(int, const double&)>(&MyClass::add), 1, 2.2);
 *   Callback::Callback* cb2 =
 *     Callback::make_ref(obj, static_cast<void (MyClass::*)(const int&, const int&)>(&MyClass::add), 4, 5);
 * @endcode
 *
 * Posting of callbacks
 * --------------------
 *
 * This file also provides a Callback::post() function which will
 * execute a callback in a glib main loop and can be used (amongst
 * other things) to pass an event from a worker thread to the main
 * program thread.  In that respect, it provides an alternative to the
 * Notifier class.  It is passed a pointer to a Callback::CallbackArg
 * object created with a call to Callback::make() or
 * Callback::make_ref().
 *
 * To provide for thread-safe automatic disconnection of the callback
 * if the callback represents a non-static method of an object which
 * may be destroyed before the callback executes in the main loop,
 * include a Releaser as a public member of that object and pass the
 * Releaser object as the second argument of Callback::post().  Note
 * that for this to be race free, the lifetime of the remote object
 * whose method is to be invoked must be determined by the thread to
 * whose main loop the callback has been attached.  When the main loop
 * begins invoking the execution of the callback, the remote object
 * must either wholly exist (in which case the callback will be
 * invoked) or have been destroyed (in which case the callback will be
 * ignored), and not be in some transient half-state governed by
 * another thread.
 *
 * Advantages as against Notifier:
 * 
 * 1. If there are a lot of different events requiring callbacks to be
 *    dispatched in the program from worker threads to the main
 *    thread, this avoids having separate Notifier objects for each
 *    event.
 * 2. It is easier to pass arguments with varying values - they can be
 *    passed as bound arguments of the callback and no special
 *    synchronisation is normally required (the call to
 *    g_source_attach() invokes locking of the main loop which will
 *    have the effect of ensuring memory visibility).  With a Notifier
 *    object it may be necessary to use an asynchronous queue to pass
 *    variable values (or to bind a reference to the data, thus
 *    normally requiring separate synchronisation).
 * 3. Although the callback would normally be sent for execution by
 *    the main program loop, and that is the default, it can be sent
 *    for execution by any thread which has its own
 *    GMainContext/GMainLoop objects.  Thus callbacks can be passed
 *    for execution between worker threads, or from the main program
 *    thread to worker threads, as well as from worker threads to the
 *    main program thread.
 *
 * Disadvantages as against Notifier:
 *
 * 1. Less efficient, as a new callback object has to be created on
 *    freestore every time the callback is invoked, together with a
 *    new SafeEmitter object if a Releaser is used to track the
 *    callback.
 * 2. Multiple callbacks relevant to a single event cannot be invoked
 *    from a single call for the event - each callback has to be
 *    separately dispatched.
 */
 
/**
 * @namespace Cgu::Callback
 * @brief This namespace provides classes encapsulating callbacks.
 *
 * \#include <c++-gtk-utils/callback.h>
 *
 * These classes encapsulate callbacks (they are closures).  They
 * comprise a generic callback creation and execution interface.
 * There is a basic Callback::Callback type, which is an entire
 * closure or 'thunk', where all the arguments are bound in the
 * constructor and is completely opaque.  Callback::CallbackArg<T> is
 * a class which takes one unbound argument of type T when the
 * callback is dispatched, with any other arguments being bound at
 * construction time.  (The opaque Callback::Callback type is in fact
 * just a typedef for Callback::CallbackArg<void>: the two types are
 * interchangeable.)  In addition, from version 1.2.10 of the library,
 * by default a callback can be executed by a Callback::CallbackArg<T>
 * object with two or three unbound arguments by providing a
 * Cgu::TypeTuple struct as the template type: see under "Usage" below
 * and @ref TypeTuple for further information.
 *
 * The classes can represent static and non-static member functions
 * and plain functions.  In the case of a non-static member function,
 * the object whose member function the callback represents must
 * remain in existence until any invocations of the callback have
 * completed.  The function referred to must be one of void return
 * type.
 *
 * The clases are particularly relevant where a callback object may
 * need to be handed between threads, or in other cases where a
 * callback object has to be passed by pointer (which will happen at
 * some stage with glib or pthreads).  They are therefore useful for
 * general event passing when used together with the Callback::post()
 * functions, or as the data argument of a call to
 * g_signal_connect_data() in a case where a better design arises when
 * passing arguments known at connect time by storing them in the
 * callback object itself, or as the continuation for GIO async
 * operations.
 *
 * The classes are also used in the Emitter/EmitterArg classes in
 * emitter.h, which enable callbacks to be connected to an emitter and
 * provide for automatic disconnection where a class object whose
 * member a callback represents ceases to exist.
 *
 * The Callback::make() functions
 * ------------------------------
 *
 * The templated helper Callback::make() functions make it trivial to
 * create a callback object of the correct type.  A maximum of two
 * bound arguments to pass to the relevant function or class method is
 * provided for and from version 1.2.10 a maximum of three unbound
 * arguments to pass at call time - but this can be extended
 * indefinitely (prior to version 1.2.10 only one unbound argument was
 * provided for).  If there are unbound arguments, they must be the
 * last (trailing) arguments of the relevant function or method to be
 * called.  Callback/CallbackArg classes do not provide for a return
 * value.  If a result is wanted, users should pass an unbound
 * argument by reference or pointer (or pointer to pointer).
 *
 * Although as mentioned above only two bound and three unbound
 * arguments are provided for, as any of those arguments can be a
 * struct, any number of arguments can be passed as members of a
 * struct (or, in C++11, a std::tuple).
 *
 * The Callback::make() functions do a direct type mapping from the
 * bound arguments of the function or method represented by the
 * callback object to the arguments stored by the callback object.
 * Bound value arguments of the relevant function or method to be
 * called are therefore stored by value in the callback object.  A
 * bound argument can comprise a reference argument (T& or const T&)
 * if the template parameters of the Callback::make() call are
 * qualified by hand to avoid a type mismatch: see under "Usage" below
 * for further particulars, and if the reference argument is non-const
 * this allows the referenced argument to be mutated.  However as this
 * would result in the lifetime of the argument not being controlled
 * by the callback object (it would not keep its own copy), it will
 * often be unsafe to do so.  (The documentation on
 * Thread::JoinableHandle gives a usage where where binding a
 * reference argument would be safe.)
 *
 * From version 1.2.13, the library also provides Callback::make_ref()
 * functions, which force the callback object to keep a copy of the
 * value passed where a target function argument is a const reference.
 * It is therefore safe with const reference arguments.  No explicit
 * type qualification is required by Callback::make_ref().  In
 * addition the Callback::make_ref() functions provide for more
 * efficient passing of class type bound arguments than does
 * Callback::make(): see further below.
 *
 * Where more than one unbound argument is to be passed to the target
 * function, the Cgu::TypeTuple type container struct is used - see
 * under Usage below for examples.
 *
 * The Callback::make_ref() functions
 * ----------------------------------
 *
 * In order to enable the widest variety of types to be accepted as
 * arguments (including mutating non-const reference arguments in
 * those cases where it is safe, and also string literals), as
 * mentioned above when constructing a callback object
 * Callback::make() receives non-reference bound arguments by value,
 * and if unoptimised these may be copied up to two times, and once
 * more when the target function is dispatched.  Where a bound
 * argument is a pointer or a fundamental type (an integral or
 * floating-point type), optimization by copy elision will reduce the
 * number of times argument copying takes place when constructing a
 * callback object to once, but the standard does not permit that with
 * class types where the constructor or destructor have side effects
 * or it cannot be ascertained whether they have side effects.
 *
 * Therefore, to cater for cases where a target function takes a class
 * type argument by const reference or value, from version 1.2.13 the
 * Callback::make_ref() functions are provided.  Unlike
 * Callback::make(), when constructing a callback for a target
 * function taking a const reference bound argument,
 * Callback::make_ref() will force the callback object to keep a copy
 * of the argument instead of a reference to that argument.  This
 * makes the use of const reference arguments safe (at the cost of the
 * taking of that copy).  It cannot be used with non-const references.
 * In addition, Callback::make_ref() automatically passes class type
 * arguments for storage by the callback object by reference to const,
 * so reducing the number of times they are copied, when stored, to
 * once.
 *
 * In the case of a value argument, at callback dispatch time one
 * additional copy will be made in the normal way when the target
 * function is called, but in the case of a const reference argument
 * no such additional copy will be made.  What all this means is that,
 * where bound arguments include a non-trivial class type, the most
 * efficient and exception safe strategy is usually to construct the
 * object of the class type on free store and held by Cgu::SharedPtr
 * or Cgu::SharedLockPtr, have the target function take it by const
 * Cgu::SharedPtr& or const Cgu::SharedLockPtr&, and construct the
 * callback object using Callback::make_ref().
 *
 * This flexibility of Callback::make_ref() has a downside: unlike
 * Callback::make(), Callback::make_ref() cannot resolve overloaded
 * functions by argument type.  Where a function has two or more
 * overloads taking the same number of arguments, explicit
 * disambiguation by the user is required (see further below under
 * Overloaded Functions).
 *
 * Summary: If a callback object's bound arguments are all simple
 * fundamental types such as pointers (including C strings), integers
 * or floating points, use Callback::make().  Where bound arguments
 * include class types, use Callback::make_ref().
 *
 * The Callback::make_val() functions
 * ----------------------------------
 *
 * The library also provides Callback::make_val() functions.  These
 * are retained to keep code compatibility with earlier versions of
 * the library.  They were optimised for use where a target function
 * takes bound arguments of class type by value, but are now
 * deprecated and superseded by the automatic variable type mapping of
 * Callback::make_ref().  Callback::make_ref() should now be used
 * instead of Callback::make_val().
 *
 * Functors
 * --------
 *
 * If a functor class of void return type is required (say for passing
 * to a c++ algorithm or container, or for automatic lifetime
 * management of the Callback object), the Callback::Functor and
 * Callback::FunctorArg wrapper classes can be used.  However, for
 * many c++ algorithms where anonymous functors created as temporaries
 * can be used, the std::ptr_fun() and MemFun::make() factory
 * functions will be a more obvious choice.
 *
 * Callback::SafeFunctor and Callback::SafeFunctorArg classes are the
 * same as Callback::Functor and Callback::FunctorArg classes, except
 * that objects of the safe version may be passed and copied between
 * threads and put in different containers in different threads (that
 * is, the reference count maintained with respect to the contained
 * callback object is thread-safe).  They use a SharedLockPtr object
 * to hold the referenced callback object.
 *
 * Memory allocation
 * -----------------
 *
 * If the library is installed using the
 * \--with-glib-memory-slices-compat or
 * \--with-glib-memory-slices-no-compat configuration options, any
 * Callback::Functor, Callback::FunctorArg, Callback::SafeFunctor or
 * Callback::SafeFunctorArg objects constructed on free store (usually
 * they won't be) will be constructed in glib memory slices.  A
 * contained Callback::Callback or Callback::CallbackArg object, which
 * will always be constructed on free store, will be constructed in
 * glib memory slices if the \--with-glib-memory-slices-no-compat
 * configuration option is chosen.
 *
 * Usage
 * -----
 *
 * For a class object my_obj of type MyClass, with a method void
 * MyClass::my_method(int, const char*), usage for a fully bound
 * callback or functor would be:
 *
 * @code 
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::Callback* cb =
 *     Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n");
 *   cb->dispatch();
 *   delete cb;
 *
 *   Callback::Functor f(Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n"));
 *   f();
 * @endcode
 *
 * Or for a partially bound callback or functor:
 *
 * @code
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::CallbackArg<const char*>* cb =
 *     Callback::make(my_obj, &MyClass::my_method, arg);
 *   cb->dispatch("Hello\n");
 *   delete cb;
 *
 *   Callback::FunctorArg<const char*> f(Callback::make(my_obj, &MyClass::my_method, arg));
 *   f("Hello\n");
 * @endcode
 *
 * To provide for two or three unbound arguments, from version 1.2.10
 * of the library the Cgu::TypeTuple struct is used (this struct has
 * no members and is never instantiated, so it does not impose any
 * overhead: see @ref TypeTuple for further information).  As in the
 * case of a single unbound argument, if there are bound arguments
 * these multiple unbound arguments must be the last (trailing)
 * arguments of the function to be called.  For a class object my_obj
 * of type MyClass, with a method void MyClass::my_method2(int, int,
 * int, const char*), usage with two unbound arguments would be:
 *
 * @code 
 *   int arg1 = 1, arg2 = 2, arg3 = 3;
 *   Cgu::Callback::CallbackArg<Cgu::TypeTuple<int, const char*> >* cb =
 *     Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1, arg2);
 *   cb->dispatch(arg3, "Hello\n");
 *   delete cb;
 *
 *   Cgu::Callback::FunctorArg<Cgu::TypeTuple<int, const char*> > f(Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1, arg2));
 *   f(arg3, "Hello\n");
 * @endcode
 *
 * and for three unbound arguments:
 *
 * @code 
 *   int arg1 = 1, arg2 = 2, arg3 = 3;
 *   Cgu::Callback::CallbackArg<Cgu::TypeTuple<int, int, const char*> >* cb =
 *     Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1);
 *   cb->dispatch(arg2, arg3, "Hello\n");
 *   delete cb;
 *
 *   Cgu::Callback::FunctorArg<Cgu::TypeTuple<int, int, const char*> > f(Cgu::Callback::make(my_obj, &MyClass::my_method2, arg1));
 *   f(arg2, arg3, "Hello\n");
 * @endcode
 *
 * The syntax for the construction of a callback object representing a
 * static member function with a signature void MyClass::my_func(int,
 * const char*), or for a normal function, is similar to the
 * non-static member function case, except that the call to
 * Callback::make would comprise:
 *
 * @code
 *   Callback::make(&MyClass::my_func, arg, "Hello\n");
 * @endcode
 * (fully bound), or
 * @code
 *   Callback::make(&MyClass::my_func, arg);
 * @endcode
 * (partially bound), and so on.
 *
 * To bind to reference arguments, the call to Callback::make() must
 * be explicitly typed.  For a class object my_obj of type MyClass,
 * with a method void MyClass::my_method(int&), usage for a fully
 * bound callback or functor would be:
 *
 * @code
 *   int arg = 1;
 *   Callback::Callback* cb =
 *     Callback::make<MyClass, int&>(my_obj, &MyClass::my_method, arg);
 * @endcode
 *
 * Note however the caveats above about binding to reference
 * arguments.
 *
 * No similar explicit typing is required by Callback::make_ref().
 * Thus for a class object my_obj of type MyClass, with a method void
 * MyClass::my_method(int, const Something&), usage for a fully bound
 * callback or functor would be:
 *
 * @code
 *   int arg1 = 1;
 *   Something arg2;
 *   Callback::Callback* cb =
 *     Callback::make_ref(my_obj, &MyClass::my_method, arg1, arg2);
 * @endcode
 *
 * Overloaded functions
 * --------------------
 *
 * Note that creating callbacks for overloaded functions can give rise
 * to an ambiguity when using Callback::make(), arising from the fact
 * that the callback object may have an unbound argument.  For
 * example:
 *
 * @code
 *   class MyClass {
 *     ...
 *     void add(int i);
 *     void add(int i, int j);
 *     void add(double d);
 *   };
 *   MyClass obj;
 *   using namespace Cgu;
 *   Callback::Callback* cb1 = Callback::make(obj, &MyClass::add, 1, 2); // ok
 *   Callback::Callback* cb2 = Callback::make(obj, &MyClass::add, 1.0);  // ok
 *   Callback::Callback* cb3 = Callback::make(obj, &MyClass::add, 1);    // ambiguous - compilation failure
 * @endcode
 *
 * The third call to Callback::make() is ambiguous, as it could be
 * creating a callback for either the function MyClass::add(int) with
 * no unbound argument (that is, creating a Callback::Callback
 * object), or the function MyClass::add(int, int) with an unbound int
 * argument (that is, creating a Callback::CallbackArg<int> object).
 * This situation could be disambiguated by specifically stating the
 * type of the function which is to be chosen, namely, to instantiate
 * the callback in the third call with:
 *
 * @code
 *   // either:
 *   Callback::Callback* cb3 =
 *     Callback::make(obj, static_cast<void (MyClass::*)(int)>(&MyClass::add), 1);
 *   // or:
 *   Callback::CallbackArg<int>* cb3 =
 *     Callback::make(obj, static_cast<void (MyClass::*)(int, int)>(&MyClass::add), 1);
 * @endcode
 *
 * Callback::make_ref() is less capable than Callback::make() at
 * deducing template types.  It cannot resolve overloaded functions by
 * examining the arguments passed to it.  For example, take a class
 * MyClass as follows:
 *
 * @code
 *   class MyClass {
 *     ...
 *     void add(int i, const double& d);
 *     void add(const int& j, const int& k);
 *   };
 * @endcode
 *
 * Callback::make_ref() would require explicit disambiguation like
 * this:
 *
 * @code
 *   Callback::Callback* cb1 =
 *     Callback::make_ref(obj, static_cast<void (MyClass::*)(int, const double&)>(&MyClass::add), 1, 2.2);
 *   Callback::Callback* cb2 =
 *     Callback::make_ref(obj, static_cast<void (MyClass::*)(const int&, const int&)>(&MyClass::add), 4, 5);
 * @endcode
 *
 * Posting of callbacks
 * --------------------
 *
 * This namespace also provides a Callback::post() function which will
 * execute a callback in a glib main loop and can be used (amongst
 * other things) to pass an event from a worker thread to the main
 * program thread.  In that respect, it provides an alternative to the
 * Notifier class.  It is passed a pointer to a Callback::CallbackArg
 * object created with a call to Callback::make() or
 * Callback::make_ref().
 *
 * To provide for thread-safe automatic disconnection of the callback
 * if the callback represents a non-static method of an object which
 * may be destroyed before the callback executes in the main loop,
 * include a Releaser as a public member of that object and pass the
 * Releaser object as the second argument of Callback::post().  Note
 * that for this to be race free, the lifetime of the remote object
 * whose method is to be invoked must be determined by the thread to
 * whose main loop the callback has been attached.  When the main loop
 * begins invoking the execution of the callback, the remote object
 * must either wholly exist (in which case the callback will be
 * invoked) or have been destroyed (in which case the callback will be
 * ignored), and not be in some transient half-state governed by
 * another thread.
 *
 * Advantages as against Notifier:
 * 
 * 1. If there are a lot of different events requiring callbacks to be
 *    dispatched in the program from worker threads to the main
 *    thread, this avoids having separate Notifier objects for each
 *    event.
 * 2. It is easier to pass arguments with varying values - they can be
 *    passed as bound arguments of the callback and no special
 *    synchronisation is normally required (the call to
 *    g_source_attach() invokes locking of the main loop which will
 *    have the effect of ensuring memory visibility).  With a Notifier
 *    object it may be necessary to use an asynchronous queue to pass
 *    variable values (or to bind a reference to the data, thus
 *    normally requiring separate synchronisation).
 * 3. Although the callback would normally be sent for execution by
 *    the main program loop, and that is the default, it can be sent
 *    for execution by any thread which has its own
 *    GMainContext/GMainLoop objects.  Thus callbacks can be passed
 *    for execution between worker threads, or from the main program
 *    thread to worker threads, as well as from worker threads to the
 *    main program thread.
 *
 * Disadvantages as against Notifier:
 *
 * 1. Less efficient, as a new callback object has to be created on
 *    freestore every time the callback is invoked, together with a
 *    new SafeEmitter object if a Releaser is used to track the
 *    callback.
 * 2. Multiple callbacks relevant to a single event cannot be invoked
 *    from a single call for the event - each callback has to be
 *    separately dispatched.
 */
 
#include <functional> // for std::less
 
#include <glib.h>
 
#include <c++-gtk-utils/shared_ptr.h>
#include <c++-gtk-utils/param.h>
#include <c++-gtk-utils/cgu_config.h>
 
namespace Cgu {
 
namespace Callback {
 
/*
   The CallbackArg class could be additionally templated to provide a
   return value, but that would affect the simplicity of the
   interface, and if a case were to arise where a result is needed, an
   alternative is for users to pass an argument by reference or
   pointer (or pointer to pointer) rather than have a return value.
*/
 
/* Declare the two basic interface types */
 
template <class FreeArg> class CallbackArg;
typedef CallbackArg<void> Callback;
 
/* now the class definitions */
 
/**
 * @class CallbackArg callback.h c++-gtk-utils/callback.h
 * @brief The callback interface class
 * @sa Callback namespace
 * @sa FunctorArg SafeFunctorArg
 *
 * This provides the basic interface class that users will generally
 * see.  The template type is the type of the unbound argument or
 * container of unbound argument types, if any.
 * Callback::CallbackArg<void> is typedef'ed to Callback::Callback.
 *
 * @b Usage
 *
 * For a class object my_obj of type MyClass, with a method void
 * MyClass::my_method(int, const char*), usage for a fully bound
 * callback would be:
 *
 * @code 
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::Callback* cb =
 *     Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n");
 *   cb->dispatch();
 *   delete cb;
 * @endcode
 *
 * Or for a partially bound callback:
 *
 * @code
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::CallbackArg<const char*>* cb =
 *     Callback::make(my_obj, &MyClass::my_method, arg);
 *   cb->dispatch("Hello\n");
 *   delete cb;
 * @endcode
 *
 * There may be up to two bound arguments and up to three unbound
 * arguments.  Callback/CallbackArg classes do not provide for a
 * return value.  If a result is wanted, users should pass an unbound
 * argument by reference or pointer (or pointer to pointer).
 *
 * For further background, including about the Callback::make() and
 * Callback::make_ref() functions, and the use of the Cgu::TypeTuple
 * struct for calls involving two or three unbound arguments, read
 * this: Callback
 */
 
template <class FreeArg>
class CallbackArg {
public:
/**
 * This will execute the referenced function or class method
 * encapsulated by this class.  It will only throw if the dispatched
 * function or class method throws, or if the copy constructor of a
 * free or bound argument throws and it is not a reference argument.
 * It is thread safe if the referenced function or class method is
 * thread safe.
 * @param arg The argument to be passed to the referenced function or
 * class method, if any.
 * @note 1. We use dispatch() to execute the callback, because the
 * callback would normally be invoked through a base class pointer.
 * To invoke it through operator()(), use the FunctorArg wrapper
 * class.
 * @note 2. This function is specialised for Callback::Callback (ie
 * Callback::CallbackArg<void>) to take no argument, and for
 * Callback::CallbackArg<TypeTuple<T1, T2> > and
 * Callback::CallbackArg<TypeTuple<T1, T2, T3> > to take two and three
 * arguments respectively.
 */
  virtual void dispatch(typename Cgu::Param<FreeArg>::ParamType arg) const = 0;
 
/**
 *  The constructor will not throw unless the copy constructor of an
 *  argument bound to the derived implementation class throws.
 */
  CallbackArg() {}
 
/**
 *  The destructor will not throw unless the destructor of an argument
 *  bound to the derived implementation class throws.
 */
  virtual ~CallbackArg() {}
 
/* these functions will be inherited by the derived callback classes */
#ifdef CGU_USE_GLIB_MEMORY_SLICES_NO_COMPAT
  CGU_GLIB_MEMORY_SLICES_FUNCS
#endif
};
 
#ifndef DOXYGEN_PARSING
 
/*
 * Partial template specialisation could be used to provide more than
 * one unbound argument to a CallbackArg object, by having a maximum
 * number of template arguments which then have a default value of
 * 'void' so enabling instantiation (by partial template
 * specialisation) of less arguments.  The problem with that approach
 * is that if the maximum number of unbound arguments is changed,
 * binary compatibility of the library is broken.
 *
 * Accordingly, the approach taken in this library is to provide the
 * template struct Cgu::TypeTuple, defined in the param.h header file.
 * This struct is never instantiated, but is instead just used as a
 * type holder.  The advantage of this approach is that binary
 * compatibility of the library is maintained, so that a user can
 * extend the number of unbound arguments by extending the type holder
 * struct (or to use, say, Loki typelists) and write additional
 * specialisations of the CallbackArg* classes.
 *
 * TODO: we could implement this scheme better by passing all the
 * class data members of the CallbackArg0, CallbackArg1, etc, concrete
 * classes to an intermediate base class, so that the specialised
 * child classes just had a dispatch() method, which would avoid much
 * of the code duplication arising from the specialisations for 2 and
 * 3 unbound arguments as added in version 1.2.10: the only function
 * we actually need to specialise for these additional arguments is
 * the dispatch() method.  However, as these classes are not PODSs
 * this would give rise to binary breakage of 1.2.9 and earlier, so we
 * have to await a suitable ABI breakage release to clean this up.
 */
 
template <class FreeArg1, class FreeArg2>
class CallbackArg <TypeTuple<FreeArg1, FreeArg2> > {
public:
  virtual void dispatch(typename Cgu::Param<FreeArg1>::ParamType arg1,
            typename Cgu::Param<FreeArg2>::ParamType arg2) const = 0;
  CallbackArg() {}
  virtual ~CallbackArg() {}
 
/* these functions will be inherited by the derived callback classes */
#ifdef CGU_USE_GLIB_MEMORY_SLICES_NO_COMPAT
  CGU_GLIB_MEMORY_SLICES_FUNCS
#endif
};
 
template <class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg <TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  virtual void dispatch(typename Cgu::Param<FreeArg1>::ParamType arg1,
            typename Cgu::Param<FreeArg2>::ParamType arg2,
            typename Cgu::Param<FreeArg3>::ParamType arg3) const = 0;
  CallbackArg() {}
  virtual ~CallbackArg() {}
 
/* these functions will be inherited by the derived callback classes */
#ifdef CGU_USE_GLIB_MEMORY_SLICES_NO_COMPAT
  CGU_GLIB_MEMORY_SLICES_FUNCS
#endif
};
 
template <>
class CallbackArg<void> {
public:
  virtual void dispatch() const = 0;
  CallbackArg() {}
  virtual ~CallbackArg() {}
 
/* these functions will be inherited by the derived callback classes */
#ifdef CGU_USE_GLIB_MEMORY_SLICES_NO_COMPAT
  CGU_GLIB_MEMORY_SLICES_FUNCS
#endif
};
 
#endif // DOXYGEN_PARSING
 
/* The four basic functor types */
 
template <class FreeArg> class FunctorArg;
template <class FreeArg> class SafeFunctorArg;
typedef FunctorArg<void> Functor;
typedef SafeFunctorArg<void> SafeFunctor;
 
/* Functor friend functions */
 
// we can use built-in operator == when comparing pointers referencing
// different objects of the same type
/**
 * Two FunctorArg objects compare equal if the addresses of the
 * CallbackArg objects they contain are the same.  This comparison
 * operator does not throw.
 */
template <class T>
bool operator==(const FunctorArg<T>& f1, const FunctorArg<T>& f2) {
  return (f1.cb_s.get() == f2.cb_s.get());
}
 
/**
 * Two FunctorArg objects compare unequal if the addresses of the
 * CallbackArg objects they contain are not the same.  This comparison
 * operator does not throw.
 *
 * Since 1.2.5
 */
template <class T>
bool operator!=(const FunctorArg<T>& f1, const FunctorArg<T>& f2) {
  return !(f1 == f2);
}
 
// we must use std::less rather than the < built-in operator for
// pointers to objects not within the same array or object: "For
// templates greater, less, greater_equal, and less_equal, the
// specializations for any pointer type yield a total order, even if
// the built-in operators <, >, <=, >= do not." (para 20.3.3/8).
/**
 * One FunctorArg object is less than another if the address of the
 * CallbackArg object contained by the first is regarded by std::less
 * as less than the address of the CallbackArg object contained by the
 * other.  This comparison operator does not throw unless std::less
 * applied to pointer types throws (which it would not do with any
 * sane implementation).
 */
template <class T>
bool operator<(const FunctorArg<T>& f1, const FunctorArg<T>& f2) {
  return std::less<const CallbackArg<T>*>()(f1.cb_s.get(), f2.cb_s.get());
}
 
/**
 * Two SafeFunctorArg objects compare equal if the addresses of the
 * CallbackArg objects they contain are not the same.  This comparison
 * operator does not throw.
 */
template <class T>
bool operator==(const SafeFunctorArg<T>& f1, const SafeFunctorArg<T>& f2) {
  return (f1.cb_s.get() == f2.cb_s.get());
}
 
/**
 * Two SafeFunctorArg objects compare unequal if the addresses of the
 * CallbackArg objects they contain are not the same.  This comparison
 * operator does not throw.
 *
 * Since 1.2.5
 */
template <class T>
bool operator!=(const SafeFunctorArg<T>& f1, const SafeFunctorArg<T>& f2) {
  return !(f1 == f2);
}
 
/**
 * One SafeFunctorArg object is less than another if the address of
 * the CallbackArg object contained by the first is regarded by
 * std::less as less than the address of the CallbackArg object
 * contained by the other.  This comparison operator does not throw
 * unless std::less applied to pointer types throws (which it would
 * not do with any sane implementation).
 */
template <class T>
bool operator<(const SafeFunctorArg<T>& f1, const SafeFunctorArg<T>& f2) {
  return std::less<const CallbackArg<T>*>()(f1.cb_s.get(), f2.cb_s.get());
}
 
/* the functor classes */
 
/**
 * @class FunctorArg callback.h c++-gtk-utils/callback.h
 * @brief Functor class holding a Callback::CallbackArg object.
 * @sa SafeFunctorArg
 * @sa Callback namespace
 *
 * This class wraps a CallbackArg object.  The callback object is kept
 * by SharedPtr so the functor can be copied and offers automatic
 * lifetime management of the wrapped callback object, as well as
 * providing an operator()() function.  Ownership is taken of the
 * CallbackArg object passed to the constructor taking a CallbackArg
 * pointer, so that constructor should be treated like a shared
 * pointer constructor - only pass a newly allocated object to it (or
 * copy construct it or assign to it from another existing FunctorArg
 * object.).  The template type is the type of the unbound argument or
 * container of unbound argument types, if any.
 * Callback::FunctorArg<void> is typedef'ed to Callback::Functor.
 *
 * The constructor taking a Callback::CallbackArg pointer is not
 * marked explicit, so the results of Callback::make() can be passed
 * directly to a function taking a Callback::FunctorArg argument, and
 * implicit conversion will take place.
 *
 * @b Usage
 *
 * For a class object my_obj of type MyClass, with a method void
 * MyClass::my_method(int, const char*), usage for a fully bound functor
 * would be:
 *
 * @code 
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::Functor f(Callback::make(my_obj, &MyClass::my_method, arg, "Hello\n"));
 *   f();
 * @endcode
 *
 * Or for a partially bound functor:
 *
 * @code
 *   using namespace Cgu;
 *   int arg = 1;
 *   Callback::FunctorArg<const char*> f(Callback::make(my_obj, &MyClass::my_method, arg));
 *   f("Hello\n");
 * @endcode
 *
 * Callback/CallbackArg classes do not provide for a return value.  If
 * a result is wanted, users should pass an unbound argument by
 * reference or pointer (or pointer to pointer).
 *
 * For further background, including about the Callback::make() and
 * Callback::make_ref() functions, and the use of the Cgu::TypeTuple
 * struct for calls with two or three unbound arguments, read this:
 * Callback
 */
 
template <class FreeArg>
class FunctorArg {
  SharedPtr<const CallbackArg<FreeArg> > cb_s;
public:
/**
 * This will execute the function or class method referenced by the
 * callback encapsulated by this object, or do nothing if this object
 * has not been initialized with a callback.  It will only throw if
 * the executed function or class method throws, or if the copy
 * constructor of a free or bound argument throws and it is not a
 * reference argument.  It is thread safe if the referenced function
 * or class method is thread safe.
 * @param arg The argument to be passed to the referenced function or
 * class method, if any.
 * @note This function is specialised for Callback::Functor (ie
 * Callback::FunctorArg<void>) to take no argument, and for
 * Callback::FunctorArg<TypeTuple<T1, T2> > and
 * Callback::FunctorArg<TypeTuple<T1, T2, T3> > to take two and three
 * arguments respectively.
 */
  void operator()(typename Cgu::Param<FreeArg>::ParamType arg) const {
    if (cb_s.get()) cb_s->dispatch(arg);
  }
 
/**
 * This comparison operator does not throw (this friend function is
 * also called by operator!=<>() from version 1.2.5).
 */
  friend bool operator== <>(const FunctorArg&, const FunctorArg&);
/**
 * This comparison operator does not throw.
 */
  friend bool operator< <>(const FunctorArg&, const FunctorArg&);
 
/**
 * Constructor of first FunctorArg holding the referenced callback.
 * As it is not marked explicit, it is also a type conversion
 * constructor.
 * @param cb The CallbackArg object which the functor is to manage.
 * @exception std::bad_alloc This might throw std::bad_alloc if
 * memory is exhausted and the system throws in that case.  Note that
 * if such an exception is thrown, then this constructor will clean
 * itself up and also delete the callback object passed to it.
 * @note 1. std::bad_alloc will not be thrown if the library has been
 * installed using the \--with-glib-memory-slices-no-compat
 * configuration option: instead glib will terminate the program if
 * it is unable to obtain memory from the operating system.
 * @note 2. This function is specialised for Callback::Functor (ie
 * Callback::FunctorArg<void>) to take a Callback::Callback argument,
 * and for Callback::FunctorArg<TypeTuple<T1, T2> > and
 * Callback::FunctorArg<TypeTuple<T1, T2, T3> > to take a
 * Callback::CallbackArg<TypeTuple<T1, T2> > and
 * Callback::CallbackArg<TypeTuple<T1, T2, T3> > argument
 * respectively.
 */
  FunctorArg(const CallbackArg<FreeArg>* cb): cb_s(cb) {}
 
/** 
 * The copy constructor does not throw.
 * @param f The assignor.
 */ 
  FunctorArg(const FunctorArg& f): cb_s(f.cb_s) {}
 
 /**
  * Default constructor, where a Callback::CallbackArg object is to be
  * assigned later (via the type conversion constructor and/or the
  * implicit assignment operator).  This constructor does not throw.
  */
  FunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
#ifndef DOXYGEN_PARSING
 
template <class FreeArg1, class FreeArg2>
class FunctorArg <TypeTuple<FreeArg1, FreeArg2> > {
  SharedPtr<const CallbackArg<TypeTuple<FreeArg1, FreeArg2> > > cb_s;
public:
  void operator()(typename Cgu::Param<FreeArg1>::ParamType arg1,
          typename Cgu::Param<FreeArg2>::ParamType arg2) const {
    if (cb_s.get()) cb_s->dispatch(arg1, arg2);
  }
 
  friend bool operator== <>(const FunctorArg&, const FunctorArg&);
  friend bool operator< <>(const FunctorArg&, const FunctorArg&);
 
  FunctorArg(const CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* cb): cb_s(cb) {}
  FunctorArg(const FunctorArg& f): cb_s(f.cb_s) {}
  FunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
template <class FreeArg1, class FreeArg2, class FreeArg3>
class FunctorArg <TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  SharedPtr<const CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > > cb_s;
public:
  void operator()(typename Cgu::Param<FreeArg1>::ParamType arg1,
          typename Cgu::Param<FreeArg2>::ParamType arg2,
          typename Cgu::Param<FreeArg3>::ParamType arg3) const {
    if (cb_s.get()) cb_s->dispatch(arg1, arg2, arg3);
  }
 
  friend bool operator== <>(const FunctorArg&, const FunctorArg&);
  friend bool operator< <>(const FunctorArg&, const FunctorArg&);
 
  FunctorArg(const CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* cb): cb_s(cb) {}
  FunctorArg(const FunctorArg& f): cb_s(f.cb_s) {}
  FunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
template <>
class FunctorArg<void> {
  SharedPtr<const Callback> cb_s;
public:
  void operator()() const {if (cb_s.get()) cb_s->dispatch();}
 
  friend bool operator== <>(const FunctorArg&, const FunctorArg&);
  friend bool operator< <>(const FunctorArg&, const FunctorArg&);
 
  FunctorArg(const Callback* cb_p): cb_s(cb_p) {}
  FunctorArg(const FunctorArg& f): cb_s(f.cb_s) {}
  FunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
#endif // DOXYGEN_PARSING
 
/**
 * @class SafeFunctorArg callback.h c++-gtk-utils/callback.h
 * @brief Functor class holding a Callback::CallbackArg object, with
 * thread-safe reference count.
 * @sa FunctorArg
 * @sa Callback namespace
 *
 * This class is the same as Callback::FunctorArg except that it will
 * provide synchronisation of the reference count between threads.
 * Use it where a functor wrapper object is to be passed between
 * threads.  The FunctorArg documentation gives details on usage.
 *
 * Callback::SafeFunctorArg<void> is typedef'ed to
 * Callback::SafeFunctor.
 *
 * For further background, read this: Callback
 */
 
template <class FreeArg>
class SafeFunctorArg {
  SharedLockPtr<const CallbackArg<FreeArg> > cb_s;
public:
/**
 * This will execute the function or class method referenced by the
 * callback encapsulated by this object, or do nothing if this object
 * has not been initialized with a callback.  It will only throw if
 * the executed function or class method throws, or if the copy
 * constructor of a free or bound argument throws and it is not a
 * reference argument.  It is thread safe if the referenced function
 * or class method is thread safe.
 * @param arg The argument to be passed to the referenced function or
 * class method, if any.
 * @note This function is specialised for Callback::SafeFunctor (ie
 * Callback::SafeFunctorArg<void>) to take no argument, and for
 * Callback::SafeFunctorArg<TypeTuple<T1, T2> > and
 * Callback::SafeFunctorArg<TypeTuple<T1, T2, T3> > to take two and
 * three arguments respectively.
 */
  void operator()(typename Cgu::Param<FreeArg>::ParamType arg) const {
    if (cb_s.get()) cb_s->dispatch(arg);
  }
 
/**
 * This comparison operator does not throw (this friend function is
 * also called by operator!=<>() from version 1.2.5).
 */
  friend bool operator== <>(const SafeFunctorArg&, const SafeFunctorArg&);
/**
 * This comparison operator does not throw.
 */
  friend bool operator< <>(const SafeFunctorArg&, const SafeFunctorArg&);
 
 /**
 * Constructor of first SafeFunctorArg holding the referenced
 * callback.  As it is not marked explicit, it is also a type
 * conversion constructor.
 * @param cb The CallbackArg object which the functor is to manage.
 * @exception std::bad_alloc This might throw std::bad_alloc if
 * memory is exhausted and the system throws in that case.  Note that
 * if such an exception is thrown, then this constructor will clean
 * itself up and also delete the callback object passed to it.
 * @note 1. std::bad_alloc will not be thrown if the library has been
 * installed using the \--with-glib-memory-slices-no-compat
 * configuration option: instead glib will terminate the program if
 * it is unable to obtain memory from the operating system.
 * @note 2. This function is specialised for Callback::SafeFunctor (ie
 * Callback::SafeFunctorArg<void>) to take a Callback::Callback
 * argument, and for Callback::SafeFunctorArg<TypeTuple<T1, T2> > and
 * Callback::SafeFunctorArg<TypeTuple<T1, T2, T3> > to take a
 * Callback::CallbackArg<TypeTuple<T1, T2> > and
 * Callback::CallbackArg<TypeTuple<T1, T2, T3> > argument
 * respectively.
 */
  SafeFunctorArg(const CallbackArg<FreeArg>* cb): cb_s(cb) {}
 
/** 
 * The copy constructor does not throw.
 * @param f The assignor.
 */ 
  SafeFunctorArg(const SafeFunctorArg& f): cb_s(f.cb_s) {}
 
 /**
  * Default constructor, where a Callback::CallbackArg object is to be
  * assigned later (via the type conversion constructor and/or the
  * implicit assignment operator).  This constructor does not throw.
  * @note The reference count maintained with respect to the contained
  * callback object is thread-safe, so SafeFunctorArg objects may be
  * copied between threads by the implicit assignment operator and put
  * in different containers in different threads.  They use a
  * SharedLockPtr object to hold the referenced callback object.
  */
  SafeFunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
#ifndef DOXYGEN_PARSING
 
template <class FreeArg1, class FreeArg2>
class SafeFunctorArg <TypeTuple<FreeArg1, FreeArg2> > {
  SharedLockPtr<const CallbackArg<TypeTuple<FreeArg1, FreeArg2> > > cb_s;
public:
  void operator()(typename Cgu::Param<FreeArg1>::ParamType arg1,
          typename Cgu::Param<FreeArg2>::ParamType arg2) const {
    if (cb_s.get()) cb_s->dispatch(arg1, arg2);
  }
 
  friend bool operator== <>(const SafeFunctorArg&, const SafeFunctorArg&);
  friend bool operator< <>(const SafeFunctorArg&, const SafeFunctorArg&);
 
  SafeFunctorArg(const CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* cb): cb_s(cb) {}
  SafeFunctorArg(const SafeFunctorArg& f): cb_s(f.cb_s) {}
  SafeFunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
template <class FreeArg1, class FreeArg2, class FreeArg3>
class SafeFunctorArg <TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  SharedLockPtr<const CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > > cb_s;
public:
  void operator()(typename Cgu::Param<FreeArg1>::ParamType arg1,
          typename Cgu::Param<FreeArg2>::ParamType arg2,
          typename Cgu::Param<FreeArg3>::ParamType arg3) const {
    if (cb_s.get()) cb_s->dispatch(arg1, arg2, arg3);
  }
 
  friend bool operator== <>(const SafeFunctorArg&, const SafeFunctorArg&);
  friend bool operator< <>(const SafeFunctorArg&, const SafeFunctorArg&);
 
  SafeFunctorArg(const CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* cb): cb_s(cb) {}
  SafeFunctorArg(const SafeFunctorArg& f): cb_s(f.cb_s) {}
  SafeFunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
template <>
class SafeFunctorArg<void> {
  SharedLockPtr<const Callback> cb_s;
public:
  void operator()() const {if (cb_s.get()) cb_s->dispatch();}
 
  friend bool operator== <>(const SafeFunctorArg&, const SafeFunctorArg&);
  friend bool operator< <>(const SafeFunctorArg&, const SafeFunctorArg&);
 
  SafeFunctorArg(const Callback* cb_p): cb_s(cb_p) {}
  SafeFunctorArg(const SafeFunctorArg& f): cb_s(f.cb_s) {}
  SafeFunctorArg() {}
 
/* Only has effect if --with-glib-memory-slices-compat or
   --with-glib-memory-slices-no-compat option picked */
  CGU_GLIB_MEMORY_SLICES_FUNCS
};
 
#endif // DOXYGEN_PARSING
 
/* the callback implementation classes */
 
template <class T>
class Callback0: public Callback {
public:
  typedef void (T::* MemFunc)();
private:
  T* obj;
  MemFunc func;
public:
  void dispatch() const {(obj->*func)();}
  Callback0(T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
template <class T, class FreeArg>
class CallbackArg0: public CallbackArg<FreeArg> {
public:
  typedef void (T::* MemFunc)(FreeArg);
private:
  T* obj;
  MemFunc func;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    (obj->*func)(free_arg);
  }
  CallbackArg0(T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <class T, class FreeArg1, class FreeArg2>
class CallbackArg0 <T, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (T::* MemFunc)(FreeArg1, FreeArg2);
private:
  T* obj;
  MemFunc func;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    (obj->*func)(free_arg1, free_arg2);
  }
  CallbackArg0(T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg0 <T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (T::* MemFunc)(FreeArg1, FreeArg2, FreeArg3);
private:
  T* obj;
  MemFunc func;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    (obj->*func)(free_arg1, free_arg2, free_arg3);
  }
  CallbackArg0(T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
#endif // DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg>
class Callback1_: public Callback {
public:
  typedef void (T::* MemFunc)(BoundArg);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch() const {(obj->*func)(arg);}
  Callback1_(T& obj_, MemFunc func_,
         typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
template <bool unref, class T, class BoundArg, class FreeArg>
class CallbackArg1_: public CallbackArg<FreeArg> {
public:
  typedef void (T::* MemFunc)(BoundArg, FreeArg);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    (obj->*func)(arg, free_arg);
  }
  CallbackArg1_(T& obj_, MemFunc func_,
        typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg, class FreeArg1, class FreeArg2>
class CallbackArg1_ <unref, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    (obj->*func)(arg, free_arg1, free_arg2);
  }
  CallbackArg1_(T& obj_, MemFunc func_,
        typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
template <bool unref, class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg1_ <unref, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2, FreeArg3);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    (obj->*func)(arg, free_arg1, free_arg2, free_arg3);
  }
  CallbackArg1_(T& obj_, MemFunc func_,
        typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
#endif // DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg1, class BoundArg2>
class Callback2_: public Callback {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch() const {(obj->*func)(arg1, arg2);}
  Callback2_(T& obj_, MemFunc func_,
         typename Cgu::Param<BoundArg1>::ParamType arg1_,
         typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
template <bool unref, class T, class BoundArg1, class BoundArg2, class FreeArg>
class CallbackArg2_: public CallbackArg<FreeArg> {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    (obj->*func)(arg1, arg2, free_arg);
  }
  CallbackArg2_(T& obj_, MemFunc func_,
        typename Cgu::Param<BoundArg1>::ParamType arg1_,
        typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
class CallbackArg2_ <unref, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    (obj->*func)(arg1, arg2, free_arg1, free_arg2);
  }
  CallbackArg2_(T& obj_, MemFunc func_,
        typename Cgu::Param<BoundArg1>::ParamType arg1_,
        typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
template <bool unref, class T, class BoundArg1, class BoundArg2,
          class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg2_ <unref, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3);
private:
  T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    (obj->*func)(arg1, arg2, free_arg1, free_arg2, free_arg3);
  }
  CallbackArg2_(T& obj_, MemFunc func_,
        typename Cgu::Param<BoundArg1>::ParamType arg1_,
        typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
#endif // DOXYGEN_PARSING
 
/* const versions, for binding to const methods */
 
template <class T>
class Callback0_const: public Callback {
public:
  typedef void (T::* MemFunc)() const;
private:
  const T* obj;
  MemFunc func;
public:
  void dispatch() const {(obj->*func)();}
  Callback0_const(const T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
template <class T, class FreeArg>
class CallbackArg0_const: public CallbackArg<FreeArg> {
public:
  typedef void (T::* MemFunc)(FreeArg) const;
private:
  const T* obj;
  MemFunc func;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    (obj->*func)(free_arg);
  }
  CallbackArg0_const(const T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <class T, class FreeArg1, class FreeArg2>
class CallbackArg0_const <T, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (T::* MemFunc)(FreeArg1, FreeArg2) const;
private:
  const T* obj;
  MemFunc func;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    (obj->*func)(free_arg1, free_arg2);
  }
  CallbackArg0_const(const T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg0_const <T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (T::* MemFunc)(FreeArg1, FreeArg2, FreeArg3) const;
private:
  const T* obj;
  MemFunc func;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    (obj->*func)(free_arg1, free_arg2, free_arg3);
  }
  CallbackArg0_const(const T& obj_, MemFunc func_): obj(&obj_), func(func_) {}
};
 
#endif // DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg>
class Callback1_const_: public Callback {
public:
  typedef void (T::* MemFunc)(BoundArg) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch() const {(obj->*func)(arg);}
  Callback1_const_(const T& obj_, MemFunc func_,
           typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
template <bool unref, class T, class BoundArg, class FreeArg>
class CallbackArg1_const_: public CallbackArg<FreeArg> {
public:
  typedef void (T::* MemFunc)(BoundArg, FreeArg) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    (obj->*func)(arg, free_arg);
  }
  CallbackArg1_const_(const T& obj_, MemFunc func_,
              typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg, class FreeArg1, class FreeArg2>
class CallbackArg1_const_ <unref, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    (obj->*func)(arg, free_arg1, free_arg2);
  }
  CallbackArg1_const_(const T& obj_, MemFunc func_,
              typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
template <bool unref, class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg1_const_ <unref, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    (obj->*func)(arg, free_arg1, free_arg2, free_arg3);
  }
  CallbackArg1_const_(const T& obj_, MemFunc func_,
              typename Cgu::Param<BoundArg>::ParamType arg_): obj(&obj_), func(func_), arg(arg_) {}
};
 
#endif // DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg1, class BoundArg2>
class Callback2_const_: public Callback {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch() const {(obj->*func)(arg1, arg2);}
  Callback2_const_(const T& obj_, MemFunc func_,
           typename Cgu::Param<BoundArg1>::ParamType arg1_,
           typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
template <bool unref, class T, class BoundArg1, class BoundArg2, class FreeArg>
class CallbackArg2_const_: public CallbackArg<FreeArg> {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    (obj->*func)(arg1, arg2, free_arg);
  }
  CallbackArg2_const_(const T& obj_, MemFunc func_,
              typename Cgu::Param<BoundArg1>::ParamType arg1_,
              typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <bool unref, class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
class CallbackArg2_const_ <unref, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    (obj->*func)(arg1, arg2, free_arg1, free_arg2);
  }
  CallbackArg2_const_(const T& obj_, MemFunc func_,
              typename Cgu::Param<BoundArg1>::ParamType arg1_,
              typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
template <bool unref, class T, class BoundArg1, class BoundArg2,
          class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg2_const_ <unref, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const;
private:
  const T* obj;
  MemFunc func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    (obj->*func)(arg1, arg2, free_arg1, free_arg2, free_arg3);
  }
  CallbackArg2_const_(const T& obj_, MemFunc func_,
              typename Cgu::Param<BoundArg1>::ParamType arg1_,
              typename Cgu::Param<BoundArg2>::ParamType arg2_): obj(&obj_), func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
#endif // DOXYGEN_PARSING
 
/* for static class methods and non-class functions */
 
class Callback0_static: public Callback {
public:
  typedef void (*Func)();
private:
  Func func;
public:
  void dispatch() const {func();}
  Callback0_static(Func func_): func(func_) {}
};
 
template <class FreeArg>
class CallbackArg0_static: public CallbackArg<FreeArg> {
public:
  typedef void (*Func)(FreeArg);
private:
  Func func;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    func(free_arg);
  }
  CallbackArg0_static(Func func_): func(func_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <class FreeArg1, class FreeArg2>
class CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (*Func)(FreeArg1, FreeArg2);
private:
  Func func;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    func(free_arg1, free_arg2);
  }
  CallbackArg0_static(Func func_): func(func_) {}
};
 
template <class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (*Func)(FreeArg1, FreeArg2, FreeArg3);
private:
  Func func;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    func(free_arg1, free_arg2, free_arg3);
  }
  CallbackArg0_static(Func func_): func(func_) {}
};
 
#endif // DOXYGEN_PARSING
 
template <bool unref, class BoundArg>
class Callback1_static_: public Callback {
public:
  typedef void (*Func)(BoundArg);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch() const {func(arg);}
  Callback1_static_(Func func_, typename Cgu::Param<BoundArg>::ParamType arg_): func(func_), arg(arg_) {}
};
 
template <bool unref, class BoundArg, class FreeArg>
class CallbackArg1_static_: public CallbackArg<FreeArg> {
public:
  typedef void (*Func)(BoundArg, FreeArg);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    func(arg, free_arg);
  }
  CallbackArg1_static_(Func func_, typename Cgu::Param<BoundArg>::ParamType arg_): func(func_), arg(arg_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <bool unref, class BoundArg, class FreeArg1, class FreeArg2>
class CallbackArg1_static_ <unref, BoundArg, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (*Func)(BoundArg, FreeArg1, FreeArg2);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    func(arg, free_arg1, free_arg2);
  }
  CallbackArg1_static_(Func func_, typename Cgu::Param<BoundArg>::ParamType arg_): func(func_), arg(arg_) {}
};
 
template <bool unref, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg1_static_ <unref, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (*Func)(BoundArg, FreeArg1, FreeArg2, FreeArg3);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg, unref>::Type arg;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    func(arg, free_arg1, free_arg2, free_arg3);
  }
  CallbackArg1_static_(Func func_, typename Cgu::Param<BoundArg>::ParamType arg_): func(func_), arg(arg_) {}
};
 
#endif // DOXYGEN_PARSING
 
template <bool unref, class BoundArg1, class BoundArg2>
class Callback2_static_: public Callback {
public:
  typedef void (*Func)(BoundArg1, BoundArg2);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch() const {func(arg1, arg2);}
  Callback2_static_(Func func_, typename Cgu::Param<BoundArg1>::ParamType arg1_,
            typename Cgu::Param<BoundArg2>::ParamType arg2_): func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
template <bool unref, class BoundArg1, class BoundArg2, class FreeArg>
class CallbackArg2_static_: public CallbackArg<FreeArg> {
public:
  typedef void (*Func)(BoundArg1, BoundArg2, FreeArg);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg>::ParamType free_arg) const {
    func(arg1, arg2, free_arg);
  }
  CallbackArg2_static_(Func func_, typename Cgu::Param<BoundArg1>::ParamType arg1_,
               typename Cgu::Param<BoundArg2>::ParamType arg2_): func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
#ifndef DOXYGEN_PARSING
 
template <bool unref, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
class CallbackArg2_static_ <unref, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2> > {
public:
  typedef void (*Func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2) const {
    func(arg1, arg2, free_arg1, free_arg2);
  }
  CallbackArg2_static_(Func func_, typename Cgu::Param<BoundArg1>::ParamType arg1_,
               typename Cgu::Param<BoundArg2>::ParamType arg2_): func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
template <bool unref, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
class CallbackArg2_static_ <unref, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
public:
  typedef void (*Func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3);
private:
  Func func;
  typename Cgu::RemoveRefCond<BoundArg1, unref>::Type arg1;
  typename Cgu::RemoveRefCond<BoundArg2, unref>::Type arg2;
public:
  void dispatch(typename Cgu::Param<FreeArg1>::ParamType free_arg1,
        typename Cgu::Param<FreeArg2>::ParamType free_arg2,
        typename Cgu::Param<FreeArg3>::ParamType free_arg3) const {
    func(arg1, arg2, free_arg1, free_arg2, free_arg3);
  }
  CallbackArg2_static_(Func func_, typename Cgu::Param<BoundArg1>::ParamType arg1_,
               typename Cgu::Param<BoundArg2>::ParamType arg2_): func(func_), arg1(arg1_), arg2(arg2_) {}
};
 
#endif // DOXYGEN_PARSING
 
#ifndef DOXYGEN_PARSING
// TODO - remove on API break
// these are for API compatibility only (they are not necessary
// for ABI compatibility as the library produces these only by
// base pointer, but a user may have instantiated them by hand
// in user code)
 
template <class T, class BoundArg>
struct Callback1: public Callback1_<false, T, BoundArg> {
  typedef void (T::* MemFunc)(BoundArg);
  Callback1(T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      Callback1_<false, T, BoundArg>(obj, func, arg) {}
};
 
template <class T, class BoundArg, class FreeArg>
struct CallbackArg1: public CallbackArg1_<false, T, BoundArg, FreeArg> {
  typedef void (T::* MemFunc)(BoundArg, FreeArg);
  CallbackArg1(T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_<false, T, BoundArg, FreeArg>(obj, func, arg) {}
};
 
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
struct CallbackArg1<T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg1_ <false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> > {
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2);
  CallbackArg1(T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_<false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(obj, func, arg) {}
};
 
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
struct CallbackArg1<T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg1_ <false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2, FreeArg3);
  CallbackArg1(T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_<false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(obj, func, arg) {}
};
 
template <class T, class BoundArg1, class BoundArg2>
struct Callback2: public Callback2_<false, T, BoundArg1, BoundArg2> {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2);
  Callback2(T& obj, MemFunc func,
        typename Cgu::Param<BoundArg1>::ParamType arg1,
        typename Cgu::Param<BoundArg2>::ParamType arg2): 
      Callback2_<false, T, BoundArg1, BoundArg2>(obj, func, arg1, arg2) {}
};
 
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
struct CallbackArg2: public CallbackArg2_<false, T, BoundArg1, BoundArg2, FreeArg> {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg);
  CallbackArg2(T& obj, MemFunc func,
           typename Cgu::Param<BoundArg1>::ParamType arg1,
           typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_<false, T, BoundArg1, BoundArg2, FreeArg>(obj, func, arg1, arg2) {}
};
 
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
struct CallbackArg2<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg2_ <false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> > {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2);
  CallbackArg2(T& obj, MemFunc func,
           typename Cgu::Param<BoundArg1>::ParamType arg1,
           typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_<false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(obj, func, arg1, arg2) {}
};
 
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
struct CallbackArg2<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg2_ <false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3);
  CallbackArg2(T& obj, MemFunc func,
           typename Cgu::Param<BoundArg1>::ParamType arg1,
           typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_<false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(obj, func, arg1, arg2) {}
};
 
template <class T, class BoundArg>
struct Callback1_const: public Callback1_const_<false, T, BoundArg> {
  typedef void (T::* MemFunc)(BoundArg) const;
  Callback1_const(const T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      Callback1_const_<false, T, BoundArg>(obj, func, arg) {}
};
 
template <class T, class BoundArg, class FreeArg>
struct CallbackArg1_const: public CallbackArg1_const_<false, T, BoundArg, FreeArg> {
  typedef void (T::* MemFunc)(BoundArg, FreeArg) const;
  CallbackArg1_const(const T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_const_<false, T, BoundArg, FreeArg>(obj, func, arg) {}
};
 
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
struct CallbackArg1_const<T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg1_const_ <false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> > {
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2) const;
  CallbackArg1_const(const T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_const_<false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(obj, func, arg) {}
};
 
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
struct CallbackArg1_const<T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg1_const_ <false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  typedef void (T::* MemFunc)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const;
  CallbackArg1_const(const T& obj, MemFunc func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_const_<false, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(obj, func, arg) {}
};
 
template <class T, class BoundArg1, class BoundArg2>
struct Callback2_const: public Callback2_const_<false, T, BoundArg1, BoundArg2> {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2) const;
  Callback2_const(const T& obj, MemFunc func,
          typename Cgu::Param<BoundArg1>::ParamType arg1,
          typename Cgu::Param<BoundArg2>::ParamType arg2): 
      Callback2_const_<false, T, BoundArg1, BoundArg2>(obj, func, arg1, arg2) {}
};
 
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
struct CallbackArg2_const: public CallbackArg2_const_<false, T, BoundArg1, BoundArg2, FreeArg> {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg) const;
  CallbackArg2_const(const T& obj, MemFunc func,
             typename Cgu::Param<BoundArg1>::ParamType arg1,
             typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_const_<false, T, BoundArg1, BoundArg2, FreeArg>(obj, func, arg1, arg2) {}
};
 
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
struct CallbackArg2_const<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg2_const_ <false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> > {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const;
  CallbackArg2_const(const T& obj, MemFunc func,
             typename Cgu::Param<BoundArg1>::ParamType arg1,
             typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_const_<false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(obj, func, arg1, arg2) {}
};
 
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
struct CallbackArg2_const<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg2_const_ <false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  typedef void (T::* MemFunc)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const;
  CallbackArg2_const(const T& obj, MemFunc func,
             typename Cgu::Param<BoundArg1>::ParamType arg1,
             typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_const_<false, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(obj, func, arg1, arg2) {}
};
 
template <class BoundArg>
struct Callback1_static: public Callback1_static_<false, BoundArg> {
  typedef void (*Func)(BoundArg);
  Callback1_static(Func func, typename Cgu::Param<BoundArg>::ParamType arg):
      Callback1_static_<false, BoundArg>(func, arg) {}
};
 
template <class BoundArg, class FreeArg>
struct CallbackArg1_static: public CallbackArg1_static_<false, BoundArg, FreeArg> {
  typedef void (*Func)(BoundArg, FreeArg);
  CallbackArg1_static(Func func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_static_<false, BoundArg, FreeArg>(func, arg) {}
};
 
template <class BoundArg, class FreeArg1, class FreeArg2>
struct CallbackArg1_static<BoundArg, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg1_static_ <false, BoundArg, TypeTuple<FreeArg1, FreeArg2> > {
  typedef void (*Func)(BoundArg, FreeArg1, FreeArg2);
  CallbackArg1_static(Func func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_static_<false, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(func, arg) {}
};
 
template <class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
struct CallbackArg1_static<BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg1_static_ <false, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  typedef void (*Func)(BoundArg, FreeArg1, FreeArg2, FreeArg3);
  CallbackArg1_static(Func func, typename Cgu::Param<BoundArg>::ParamType arg):
      CallbackArg1_static_<false, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg) {}
};
 
template <class BoundArg1, class BoundArg2>
struct Callback2_static: public Callback2_static_<false, BoundArg1, BoundArg2> {
  typedef void (*Func)(BoundArg1, BoundArg2);
  Callback2_static(Func func,
           typename Cgu::Param<BoundArg1>::ParamType arg1,
           typename Cgu::Param<BoundArg2>::ParamType arg2): 
      Callback2_static_<false, BoundArg1, BoundArg2>(func, arg1, arg2) {}
};
 
template <class BoundArg1, class BoundArg2, class FreeArg>
struct CallbackArg2_static: public CallbackArg2_static_<false, BoundArg1, BoundArg2, FreeArg> {
  typedef void (*Func)(BoundArg1, BoundArg2, FreeArg);
  CallbackArg2_static(Func func,
              typename Cgu::Param<BoundArg1>::ParamType arg1,
              typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_static_<false, BoundArg1, BoundArg2, FreeArg>(func, arg1, arg2) {}
};
 
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
struct CallbackArg2_static<BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >:
      public CallbackArg2_static_ <false, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> > {
  typedef void (*Func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2);
  CallbackArg2_static(Func func,
              typename Cgu::Param<BoundArg1>::ParamType arg1,
              typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_static_<false, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(func, arg1, arg2) {}
};
 
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
struct CallbackArg2_static<BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >:
      public CallbackArg2_static_ <false, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> > {
  typedef void (*Func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3);
  CallbackArg2_static(Func func,
              typename Cgu::Param<BoundArg1>::ParamType arg1,
              typename Cgu::Param<BoundArg2>::ParamType arg2): 
      CallbackArg2_static_<false, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg1, arg2) {}
};
 
#endif
 
/* Convenience functions making callback objects on freestore.  These
 * can for example be passed as the first argument of the
 * Thread::start() method in thread.h. They are also used by the
 * Callback::post() function.
*/
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 */
template <class T>
Callback* make(T& t,
           void (T::*func)()) {
  return new Callback0<T>(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.8
 */
template <class T>
Callback* make_val(T& t,
           void (T::*func)()) {
  return new Callback0<T>(t, func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T>
Callback* make_ref(T& t,
           void (T::*func)()) {
  return new Callback0<T>(t, func);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 */
template <class T, class FreeArg>
CallbackArg<FreeArg>* make(T& t,
               void (T::*func)(FreeArg)) {
  return new CallbackArg0<T, FreeArg>(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.8
 */
template <class T, class FreeArg>
CallbackArg<FreeArg>* make_val(T& t,
                   void (T::*func)(FreeArg)) {
  return new CallbackArg0<T, FreeArg>(t, func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T, class FreeArg>
CallbackArg<FreeArg>* make_ref(T& t,
                   void (T::*func)(FreeArg)) {
  return new CallbackArg0<T, FreeArg>(t, func);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(T& t,
                          void (T::*func)(FreeArg1, FreeArg2)) {
  return new CallbackArg0<T, TypeTuple<FreeArg1, FreeArg2> >(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(T& t,
                              void (T::*func)(FreeArg1, FreeArg2)) {
  return new CallbackArg0<T, TypeTuple<FreeArg1, FreeArg2> >(t, func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(T& t,
                              void (T::*func)(FreeArg1, FreeArg2)) {
  return new CallbackArg0<T, TypeTuple<FreeArg1, FreeArg2> >(t, func);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(T& t,
                                  void (T::*func)(FreeArg1, FreeArg2, FreeArg3)) {
  return new CallbackArg0<T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(T& t,
                                  void (T::*func)(FreeArg1, FreeArg2, FreeArg3)) {
  return new CallbackArg0<T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func);
}
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(T& t,
                                  void (T::*func)(FreeArg1, FreeArg2, FreeArg3)) {
  return new CallbackArg0<T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg>
Callback* make(T& t,
           void (T::*func)(BoundArg),
           BoundArg arg) {
  return new Callback1<T, BoundArg>(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg>
Callback* make_val(T& t,
           void (T::*func)(BoundArg),
           const BoundArg& arg) {
  return new Callback1<T, BoundArg>(t, func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg>
Callback* make_ref(T& t,
           void (T::*func)(BoundArg),
           typename Cgu::Param<BoundArg>::ParamType arg) {
  return new Callback1_<true, T, BoundArg>(t, func, arg);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make(T& t,
               void (T::*func)(BoundArg, FreeArg),
               BoundArg arg) {
  return new CallbackArg1<T, BoundArg, FreeArg>(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make_val(T& t,
                   void (T::*func)(BoundArg, FreeArg),
                   const BoundArg& arg) {
  return new CallbackArg1<T, BoundArg, FreeArg>(t, func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make_ref(T& t,
                   void (T::*func)(BoundArg, FreeArg),
                   typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_<true, T, BoundArg, FreeArg>(t, func, arg);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(T& t,
                          void (T::*func)(BoundArg, FreeArg1, FreeArg2),
                          BoundArg arg) {
  return new CallbackArg1<T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(T& t,
                              void (T::*func)(BoundArg, FreeArg1, FreeArg2),
                              const BoundArg& arg) {
  return new CallbackArg1<T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(T& t,
                              void (T::*func)(BoundArg, FreeArg1, FreeArg2),
                              typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_<true, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(T& t,
                                void (T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3),
                                BoundArg arg) {
  return new CallbackArg1<T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(T& t,
                                void (T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3),
                                const BoundArg& arg) {
  return new CallbackArg1<T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
 
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(T& t,
                                void (T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3),
                                typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_<true, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg1, class BoundArg2>
Callback* make(T& t,
           void (T::*func)(BoundArg1, BoundArg2),
           BoundArg1 arg1,
           BoundArg2 arg2) {
  return new Callback2<T, BoundArg1, BoundArg2>(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg1, class BoundArg2>
Callback* make_val(T& t,
           void (T::*func)(BoundArg1, BoundArg2),
           const BoundArg1& arg1,
           const BoundArg2& arg2) {
  return new Callback2<T, BoundArg1, BoundArg2>(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2>
Callback* make_ref(T& t,
           void (T::*func)(BoundArg1, BoundArg2),
           typename Cgu::Param<BoundArg1>::ParamType arg1,
           typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new Callback2_<true, T, BoundArg1, BoundArg2>(t, func, arg1, arg2);
}
 
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make(T& t,
               void (T::*func)(BoundArg1, BoundArg2, FreeArg),
               BoundArg1 arg1,
               BoundArg2 arg2) {
  return new CallbackArg2<T, BoundArg1, BoundArg2, FreeArg>(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make_val(T& t,
                   void (T::*func)(BoundArg1, BoundArg2, FreeArg),
                   const BoundArg1& arg1,
                   const BoundArg2& arg2) {
  return new CallbackArg2<T, BoundArg1, BoundArg2, FreeArg>(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make_ref(T& t,
                   void (T::*func)(BoundArg1, BoundArg2, FreeArg),
                   typename Cgu::Param<BoundArg1>::ParamType arg1,
                   typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_<true, T, BoundArg1, BoundArg2, FreeArg>(t, func, arg1, arg2);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(T& t,
                          void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2),
                          BoundArg1 arg1,
                          BoundArg2 arg2) {
  return new CallbackArg2<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(T& t,
                              void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2),
                              const BoundArg1& arg1,
                              const BoundArg2& arg2) {
  return new CallbackArg2<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(T& t,
                              void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2),
                              typename Cgu::Param<BoundArg1>::ParamType arg1,
                              typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_<true, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg1, arg2);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(T& t,
                                void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3),
                                BoundArg1 arg1,
                                BoundArg2 arg2) {
  return new CallbackArg2<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(T& t,
                                void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3),
                                const BoundArg1& arg1,
                                const BoundArg2& arg2) {
  return new CallbackArg2<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(T& t,
                                void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3),
                                typename Cgu::Param<BoundArg1>::ParamType arg1,
                                typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_<true, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg1, arg2);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/* const versions, for binding to const methods */
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 */
template <class T>
Callback* make(const T& t,
           void (T::*func)() const) {
  return new Callback0_const<T>(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.8
 */
template <class T>
Callback* make_val(const T& t,
           void (T::*func)() const) {
  return new Callback0_const<T>(t, func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T>
Callback* make_ref(const T& t,
           void (T::*func)() const) {
  return new Callback0_const<T>(t, func);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 */
template <class T, class FreeArg>
CallbackArg<FreeArg>* make(const T& t,
               void (T::*func)(FreeArg) const) {
  return new CallbackArg0_const<T, FreeArg>(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.8
 */
template <class T, class FreeArg>
CallbackArg<FreeArg>* make_val(const T& t,
                   void (T::*func)(FreeArg) const) {
  return new CallbackArg0_const<T, FreeArg>(t, func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T, class FreeArg>
CallbackArg<FreeArg>* make_ref(const T& t,
                   void (T::*func)(FreeArg) const) {
  return new CallbackArg0_const<T, FreeArg>(t, func);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(const T& t,
                          void (T::*func)(FreeArg1, FreeArg2) const) {
  return new CallbackArg0_const<T, TypeTuple<FreeArg1, FreeArg2> >(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(const T& t,
                              void (T::*func)(FreeArg1, FreeArg2) const) {
  return new CallbackArg0_const<T, TypeTuple<FreeArg1, FreeArg2> >(t, func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(const T& t,
                              void (T::*func)(FreeArg1, FreeArg2) const) {
  return new CallbackArg0_const<T, TypeTuple<FreeArg1, FreeArg2> >(t, func);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(const T& t,
                                  void (T::*func)(FreeArg1, FreeArg2, FreeArg3) const) {
  return new CallbackArg0_const<T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(const T& t,
                                  void (T::*func)(FreeArg1, FreeArg2, FreeArg3) const) {
  return new CallbackArg0_const<T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class T, class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(const T& t,
                                  void (T::*func)(FreeArg1, FreeArg2, FreeArg3) const) {
  return new CallbackArg0_const<T, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg>
Callback* make(const T& t,
           void (T::*func)(BoundArg) const,
           BoundArg arg) {
  return new Callback1_const<T, BoundArg>(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg>
Callback* make_val(const T& t,
           void (T::*func)(BoundArg) const,
           const BoundArg& arg) {
  return new Callback1_const<T, BoundArg>(t, func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg>
Callback* make_ref(const T& t,
           void (T::*func)(BoundArg) const,
           typename Cgu::Param<BoundArg>::ParamType arg) {
  return new Callback1_const_<true, T, BoundArg>(t, func, arg);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make(const T& t,
               void (T::*func)(BoundArg, FreeArg) const,
               BoundArg arg) {
  return new CallbackArg1_const<T, BoundArg, FreeArg>(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make_val(const T& t,
                   void (T::*func)(BoundArg, FreeArg) const,
                   const BoundArg& arg) {
  return new CallbackArg1_const<T, BoundArg, FreeArg>(t, func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make_ref(const T& t,
                   void (T::*func)(BoundArg, FreeArg) const,
                   typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_const_<true, T, BoundArg, FreeArg>(t, func, arg);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(const T& t,
                          void (T::*func)(BoundArg, FreeArg1, FreeArg2) const,
                          BoundArg arg) {
  return new CallbackArg1_const<T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(const T& t,
                              void (T::*func)(BoundArg, FreeArg1, FreeArg2) const,
                              const BoundArg& arg) {
  return new CallbackArg1_const<T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(const T& t,
                              void (T::*func)(BoundArg, FreeArg1, FreeArg2) const,
                              typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_const_<true, T, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(const T& t,
                                void (T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const,
                                BoundArg arg) {
  return new CallbackArg1_const<T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(const T& t,
                                void (T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const,
                                const BoundArg& arg) {
  return new CallbackArg1_const<T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(const T& t,
                                void (T::*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3) const,
                                typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_const_<true, T, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg1, class BoundArg2>
Callback* make(const T& t,
           void (T::*func)(BoundArg1, BoundArg2) const,
           BoundArg1 arg1,
           BoundArg2 arg2) {
  return new Callback2_const<T, BoundArg1, BoundArg2>(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg1, class BoundArg2>
Callback* make_val(const T& t,
           void (T::*func)(BoundArg1, BoundArg2) const,
           const BoundArg1& arg1,
           const BoundArg2& arg2) {
  return new Callback2_const<T, BoundArg1, BoundArg2>(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2>
Callback* make_ref(const T& t,
           void (T::*func)(BoundArg1, BoundArg2) const,
           typename Cgu::Param<BoundArg1>::ParamType arg1,
           typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new Callback2_const_<true, T, BoundArg1, BoundArg2>(t, func, arg1, arg2);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make(const T& t,
               void (T::*func)(BoundArg1, BoundArg2, FreeArg) const,
               BoundArg1 arg1,
               BoundArg2 arg2) {
  return new CallbackArg2_const<T, BoundArg1, BoundArg2, FreeArg>(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make_val(const T& t,
                   void (T::*func)(BoundArg1, BoundArg2, FreeArg) const,
                   const BoundArg1& arg1,
                   const BoundArg2& arg2) {
  return new CallbackArg2_const<T, BoundArg1, BoundArg2, FreeArg>(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make_ref(const T& t,
                   void (T::*func)(BoundArg1, BoundArg2, FreeArg) const,
                   typename Cgu::Param<BoundArg1>::ParamType arg1,
                   typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_const_<true, T, BoundArg1, BoundArg2, FreeArg>(t, func, arg1, arg2);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(const T& t,
                          void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const,
                          BoundArg1 arg1,
                          BoundArg2 arg2) {
  return new CallbackArg2_const<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(const T& t,
                              void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const,
                              const BoundArg1& arg1,
                              const BoundArg2& arg2) {
  return new CallbackArg2_const<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(const T& t,
                              void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2) const,
                              typename Cgu::Param<BoundArg1>::ParamType arg1,
                              typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_const_<true, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(t, func, arg1, arg2);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(const T& t,
                                void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const,
                                BoundArg1 arg1,
                                BoundArg2 arg2) {
  return new CallbackArg2_const<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(const T& t,
                                void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const,
                                const BoundArg1& arg1,
                                const BoundArg2& arg2) {
  return new CallbackArg2_const<T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class T, class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(const T& t,
                                void (T::*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3) const,
                                typename Cgu::Param<BoundArg1>::ParamType arg1,
                                typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_const_<true, T, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(t, func, arg1, arg2);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/* for static class methods and non-class functions */
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 */
inline Callback* make(void (*func)()) {
  return new Callback0_static(func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.8
 */
inline Callback* make_val(void (*func)()) {
  return new Callback0_static(func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
inline Callback* make_ref(void (*func)()) {
  return new Callback0_static(func);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 */
template <class FreeArg>
CallbackArg<FreeArg>* make(void (*func)(FreeArg)) {
  return new CallbackArg0_static<FreeArg>(func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.8
 */
template <class FreeArg>
CallbackArg<FreeArg>* make_val(void (*func)(FreeArg)) {
  return new CallbackArg0_static<FreeArg>(func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class FreeArg>
CallbackArg<FreeArg>* make_ref(void (*func)(FreeArg)) {
  return new CallbackArg0_static<FreeArg>(func);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(void (*func)(FreeArg1, FreeArg2)) {
  return new CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2> >(func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(void (*func)(FreeArg1, FreeArg2)) {
  return new CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2> >(func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(void (*func)(FreeArg1, FreeArg2)) {
  return new CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2> >(func);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(void (*func)(FreeArg1, FreeArg2, FreeArg3)) {
  return new CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func);
}
 
/**
 * DEPRECATED.
 *
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(void (*func)(FreeArg1, FreeArg2, FreeArg3)) {
  return new CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func);
}
 
/**
 * Since this function constructs a callback which does not take a
 * bound argument, it is a synonym for make() (the two are identical).
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.13
 */
template <class FreeArg1, class FreeArg2, class FreeArg3>
  CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(void (*func)(FreeArg1, FreeArg2, FreeArg3)) {
  return new CallbackArg0_static<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class BoundArg>
Callback* make(void (*func)(BoundArg),
           BoundArg arg) {
  return new Callback1_static<BoundArg>(func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class BoundArg>
Callback* make_val(void (*func)(BoundArg),
           const BoundArg& arg) {
  return new Callback1_static<BoundArg>(func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg>
Callback* make_ref(void (*func)(BoundArg),
           typename Cgu::Param<BoundArg>::ParamType arg) {
  return new Callback1_static_<true, BoundArg>(func, arg);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make(void (*func)(BoundArg, FreeArg),
               BoundArg arg) {
  return new CallbackArg1_static<BoundArg, FreeArg>(func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make_val(void (*func)(BoundArg, FreeArg),
                   const BoundArg& arg) {
  return new CallbackArg1_static<BoundArg, FreeArg>(func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg, class FreeArg>
CallbackArg<FreeArg>* make_ref(void (*func)(BoundArg, FreeArg),
                   typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_static_<true, BoundArg, FreeArg>(func, arg);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(void (*func)(BoundArg, FreeArg1, FreeArg2),
                          BoundArg arg) {
  return new CallbackArg1_static<BoundArg, TypeTuple<FreeArg1, FreeArg2> >(func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(void (*func)(BoundArg, FreeArg1, FreeArg2),
                              const BoundArg& arg) {
  return new CallbackArg1_static<BoundArg, TypeTuple<FreeArg1, FreeArg2> >(func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(void (*func)(BoundArg, FreeArg1, FreeArg2),
                              typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_static_<true, BoundArg, TypeTuple<FreeArg1, FreeArg2> >(func, arg);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(void (*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3),
                                BoundArg arg) {
  return new CallbackArg1_static<BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(void (*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3),
                                const BoundArg& arg) {
  return new CallbackArg1_static<BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(void (*func)(BoundArg, FreeArg1, FreeArg2, FreeArg3),
                                typename Cgu::Param<BoundArg>::ParamType arg) {
  return new CallbackArg1_static_<true, BoundArg, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class BoundArg1, class BoundArg2>
Callback* make(void (*func)(BoundArg1, BoundArg2),
           BoundArg1 arg1,
           BoundArg2 arg2) {
  return new Callback2_static<BoundArg1, BoundArg2>(func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class BoundArg1, class BoundArg2>
Callback* make_val(void (*func)(BoundArg1, BoundArg2),
           const BoundArg1& arg1,
           const BoundArg2& arg2) {
  return new Callback2_static<BoundArg1, BoundArg2>(func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg1, class BoundArg2>
Callback* make_ref(void (*func)(BoundArg1, BoundArg2),
           typename Cgu::Param<BoundArg1>::ParamType arg1,
           typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new Callback2_static_<true, BoundArg1, BoundArg2>(func, arg1, arg2);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make(void (*func)(BoundArg1, BoundArg2, FreeArg),
               BoundArg1 arg1,
               BoundArg2 arg2) {
  return new CallbackArg2_static<BoundArg1, BoundArg2, FreeArg>(func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.8
 */
template <class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make_val(void (*func)(BoundArg1, BoundArg2, FreeArg),
                   const BoundArg1& arg1,
                   const BoundArg2& arg2) {
  return new CallbackArg2_static<BoundArg1, BoundArg2, FreeArg>(func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg1, class BoundArg2, class FreeArg>
CallbackArg<FreeArg>* make_ref(void (*func)(BoundArg1, BoundArg2, FreeArg),
                   typename Cgu::Param<BoundArg1>::ParamType arg1,
                   typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_static_<true, BoundArg1, BoundArg2, FreeArg>(func, arg1, arg2);
}
 
#if defined(CGU_USE_TYPE_TUPLE_ARGS) || defined(DOXYGEN_PARSING)
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 */
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make(void (*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2),
                          BoundArg1 arg1,
                          BoundArg2 arg2) {
  return new CallbackArg2_static<BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case.  This exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option (instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).
 *
 * Since 1.2.10
 */
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_val(void (*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2),
                              const BoundArg1& arg1,
                              const BoundArg2& arg2) {
  return new CallbackArg2_static<BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2>
CallbackArg<TypeTuple<FreeArg1, FreeArg2> >* make_ref(void (*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2),
                              typename Cgu::Param<BoundArg1>::ParamType arg1,
                              typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_static_<true, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2> >(func, arg1, arg2);
}
 
/**
 * A convenience function to make Callback::CallbackArg objects
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make(void (*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3),
                                BoundArg1 arg1,
                                BoundArg2 arg2) {
  return new CallbackArg2_static<BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg1, arg2);
}
 
/**
 * DEPRECATED: use Callback::make_ref() instead.
 *
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function receives an argument of
 * class type by value which is to be a bound argument, so the
 * compiler is not able to carry out copy elision when constructing
 * the callback object.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws and it is not a reference
 * argument.
 *
 * Since 1.2.10
 */
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_val(void (*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3),
                                const BoundArg1& arg1,
                                const BoundArg2& arg2) {
  return new CallbackArg2_static<BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg1, arg2);
}
 
/**
 * An alternative function to make Callback::CallbackArg objects,
 * which is for use where a target function either receives a class
 * type bound argument by value, or receives a bound argument by
 * reference to const in a case where the generated CallbackArg object
 * is to store a copy of that argument instead of just keeping a
 * reference.
 * @exception std::bad_alloc It might throw std::bad_alloc if memory
 * is exhausted and the system throws in that case (this exception
 * will not be thrown if the library has been installed using the
 * \--with-glib-memory-slices-no-compat configuration option: instead
 * glib will terminate the program if it is unable to obtain memory
 * from the operating system).  It will also throw if the copy
 * constructor of a bound argument throws.
 *
 * Since 1.2.13
 */
template <class BoundArg1, class BoundArg2, class FreeArg1, class FreeArg2, class FreeArg3>
CallbackArg<TypeTuple<FreeArg1, FreeArg2, FreeArg3> >* make_ref(void (*func)(BoundArg1, BoundArg2, FreeArg1, FreeArg2, FreeArg3),
                                typename Cgu::Param<BoundArg1>::ParamType arg1,
                                typename Cgu::Param<BoundArg2>::ParamType arg2) {
  return new CallbackArg2_static_<true, BoundArg1, BoundArg2, TypeTuple<FreeArg1, FreeArg2, FreeArg3> >(func, arg1, arg2);
}
#endif // CGU_USE_TYPE_TUPLE_ARGS
 
} // namespace Callback
 
class Releaser;
 
namespace Callback {
 
/**
 * Posts a callback for execution by a glib main loop.  It is
 * thread-safe provided that (if glib < 2.32 is used) g_thread_init()
 * has been called.  glib >= 2.32 does not require g_thread_init() to
 * be called.  This function will not throw.
 * @param cb The callback object.  Ownership is taken of this object,
 * and it will be deleted when it has been finished with.
 * @param priority The priority to be given to the callback in the
 * main loop.  In ascending order of priorities, priorities are
 * G_PRIORITY_LOW, G_PRIORITY_DEFAULT_IDLE, G_PRIORITY_HIGH_IDLE,
 * G_PRIORITY_DEFAULT and G_PRIORITY_HIGH. The default is
 * G_PRIORITY_DEFAULT_IDLE.  This determines the order in which the
 * callback will appear in the event list in the main loop, not the
 * priority which the OS will adopt
 * @param context The glib main loop context in which the callback is
 * to be executed (the default of NULL will cause the callback to be
 * executed in the main program loop, and this is usually what is
 * wanted).
 * @note 1. Cancellation of the receiving thread is blocked when the
 * callback executes.
 * @note 2. If the callback throws an exception, the exception will be
 * consumed to protect the main loop and a g_critical() warning will
 * be issued.
 * 
 * Since 0.9.2 choice of main context available.
 */
void post(const Callback* cb, gint priority = G_PRIORITY_DEFAULT_IDLE,
      GMainContext* context = 0);
 
/**
 * Posts a callback for execution by a glib main loop.  It is
 * thread-safe provided that (if glib < 2.32 is used) g_thread_init()
 * has been called.  glib >= 2.32 does not require g_thread_init() to
 * be called.  This function will not throw.
 * @param cb The callback object.  Ownership is taken of this object,
 * and it will be deleted when it has been finished with.
 * @param r A Releaser object for automatic disconnection of the
 * callback before it executes in the main loop (mainly relevant if
 * the callback represents a non-static member function of an object
 * which may be destroyed before the callback executes).
 * @param priority The priority to be given to the callback in the
 * main loop.  In ascending order of priorities, priorities are
 * G_PRIORITY_LOW, G_PRIORITY_DEFAULT_IDLE, G_PRIORITY_HIGH_IDLE,
 * G_PRIORITY_DEFAULT and G_PRIORITY_HIGH. The default is
 * G_PRIORITY_DEFAULT_IDLE.  This determines the order in which the
 * callback will appear in the event list in the main loop, not the
 * priority which the OS will adopt.
 * @param context The glib main loop context in which the callback is
 * to be executed (the default of NULL will cause the callback to be
 * executed in the main program loop, and this is usually what is
 * wanted).
 * @exception std::bad_alloc This function might throw std::bad_alloc
 * if memory is exhausted and the system throws in that case.  If it
 * does so, the Callback object will be disposed of.
 * @exception Cgu::Thread::MutexError This function might throw
 * Cgu:Thread::MutexError if initialisation of the mutex in a
 * SafeEmitterArg object constructed by this function fails.  If it
 * does so, the Callback object will be disposed of.  (It is often not
 * worth checking for this exception, as it means either memory is
 * exhausted or pthread has run out of other resources to create new
 * mutexes.)
 * @note 1. Cancellation of the receiving thread is blocked when the
 * callback executes.
 * @note 2. If the callback throws an exception, the exception will be
 * consumed to protect the main loop and a g_critical() warning will
 * be issued.
 * @note 3. By virtue of the Releaser object, it is in theory possible
 * (if memory is exhausted and the system throws in that case) that an
 * internal SafeEmitterArg object will throw std::bad_alloc when
 * emitting/executing the callback in the glib main loop, with the
 * result that the relevant callback will not execute (instead the
 * exception will be consumed and a g_critical() warning will be
 * issued).  This is rarely of any relevance because glib will abort
 * the program if it is itself unable to obtain memory from the
 * operating system.  However, where it is relevant, design the
 * program so that it is not necessary to provide a releaser object.
 * 
 * Since 0.9.2 choice of main context available.
 */
void post(const Callback* cb, Releaser& r,
      gint priority = G_PRIORITY_DEFAULT_IDLE, GMainContext* context = 0);
 
} // namespace Callback
 
} // namespace Cgu
 
#endif