base/bind_internal.h.pump - chromium/src - Git at Google

 $$ This is a pump file for generating file templates.  Pump is a python
 $$ script that is part of the Google Test suite of utilities.  Description
 $$ can be found here:
 $$
 $$ http://code.google.com/p/googletest/wiki/PumpManual
 $$

 $$ See comment for MAX_ARITY in base/bind.h.pump.
 $var MAX_ARITY = 7
 $range ARITY 0..MAX_ARITY

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef BASE_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_

 #include "base/bind_helpers.h"
 #include "base/callback_internal.h"
 #include "base/memory/raw_scoped_refptr_mismatch_checker.h"
 #include "base/memory/weak_ptr.h"
 #include "base/template_util.h"
 #include "build/build_config.h"

 #if defined(OS_WIN)
 #include "base/bind_internal_win.h"
 #endif

 namespace base {
 namespace internal {

 // See base/callback.h for user documentation.
 //
 //
 // CONCEPTS:
 //  Runnable -- A type (really a type class) that has a single Run() method
 //              and a RunType typedef that corresponds to the type of Run().
 //              A Runnable can declare that it should treated like a method
 //              call by including a typedef named IsMethod.  The value of
 //              this typedef is NOT inspected, only the existence.  When a
 //              Runnable declares itself a method, Bind() will enforce special
 //              refcounting + WeakPtr handling semantics for the first
 //              parameter which is expected to be an object.
 //  Functor -- A copyable type representing something that should be called.
 //             All function pointers, Callback<>, and Runnables are functors
 //             even if the invocation syntax differs.
 //  RunType -- A function type (as opposed to function _pointer_ type) for
 //             a Run() function.  Usually just a convenience typedef.
 //  (Bound)ArgsType -- A function type that is being (ab)used to store the
 //                     types of set of arguments.  The "return" type is always
 //                     void here.  We use this hack so that we do not need
 //                     a new type name for each arity of type. (eg.,
 //                     BindState1, BindState2).  This makes forward
 //                     declarations and friending much much easier.
 //
 // Types:
 //  RunnableAdapter<> -- Wraps the various "function" pointer types into an
 //                       object that adheres to the Runnable interface.
 //                       There are |3*ARITY| RunnableAdapter types.
 //  FunctionTraits<> -- Type traits that unwrap a function signature into a
 //                      a set of easier to use typedefs.  Used mainly for
 //                      compile time asserts.
 //                      There are |ARITY| FunctionTraits types.
 //  ForceVoidReturn<> -- Helper class for translating function signatures to
 //                       equivalent forms with a "void" return type.
 //                    There are |ARITY| ForceVoidReturn types.
 //  FunctorTraits<> -- Type traits used determine the correct RunType and
 //                     RunnableType for a Functor.  This is where function
 //                     signature adapters are applied.
 //                    There are |ARITY| ForceVoidReturn types.
 //  MakeRunnable<> -- Takes a Functor and returns an object in the Runnable
 //                    type class that represents the underlying Functor.
 //                    There are |O(1)| MakeRunnable types.
 //  InvokeHelper<> -- Take a Runnable + arguments and actully invokes it.
 //                    Handle the differing syntaxes needed for WeakPtr<> support,
 //                    and for ignoring return values.  This is separate from
 //                    Invoker to avoid creating multiple version of Invoker<>
 //                    which grows at O(n^2) with the arity.
 //                    There are |k*ARITY| InvokeHelper types.
 //  Invoker<> -- Unwraps the curried parameters and executes the Runnable.
 //               There are |(ARITY^2 + ARITY)/2| Invoketypes.
 //  BindState<> -- Stores the curried parameters, and is the main entry point
 //                 into the Bind() system, doing most of the type resolution.
 //                 There are ARITY BindState types.

 // RunnableAdapter<>
 //
 // The RunnableAdapter<> templates provide a uniform interface for invoking
 // a function pointer, method pointer, or const method pointer. The adapter
 // exposes a Run() method with an appropriate signature. Using this wrapper
 // allows for writing code that supports all three pointer types without
 // undue repetition.  Without it, a lot of code would need to be repeated 3
 // times.
 //
 // For method pointers and const method pointers the first argument to Run()
 // is considered to be the received of the method.  This is similar to STL's
 // mem_fun().
 //
 // This class also exposes a RunType typedef that is the function type of the
 // Run() function.
 //
 // If and only if the wrapper contains a method or const method pointer, an
 // IsMethod typedef is exposed.  The existence of this typedef (NOT the value)
 // marks that the wrapper should be considered a method wrapper.

 template <typename Functor>
 class RunnableAdapter;

 $for ARITY [[
 $range ARG 1..ARITY

 // Function: Arity $(ARITY).
 template <typename R[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 class RunnableAdapter<R(*)($for ARG , [[A$(ARG)]])> {
  public:
   typedef R (RunType)($for ARG , [[A$(ARG)]]);

   explicit RunnableAdapter(R(*function)($for ARG , [[A$(ARG)]]))
       : function_(function) {
   }

   R Run($for ARG , [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
     return function_($for ARG , [[CallbackForward(a$(ARG))]]);
   }

  private:
   R (*function_)($for ARG , [[A$(ARG)]]);
 };

 // Method: Arity $(ARITY).
 template <typename R, typename T[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 class RunnableAdapter<R(T::*)($for ARG , [[A$(ARG)]])> {
  public:
   typedef R (RunType)(T*[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG)]]);
   typedef true_type IsMethod;

   explicit RunnableAdapter(R(T::*method)($for ARG , [[A$(ARG)]]))
       : method_(method) {
   }

   R Run(T* object[[]]
 $if ARITY > 0[[, ]]  $for ARG, [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
     return (object->*method_)($for ARG , [[CallbackForward(a$(ARG))]]);
   }

  private:
   R (T::*method_)($for ARG , [[A$(ARG)]]);
 };

 // Const Method: Arity $(ARITY).
 template <typename R, typename T[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 class RunnableAdapter<R(T::*)($for ARG , [[A$(ARG)]]) const> {
  public:
   typedef R (RunType)(const T*[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG)]]);
   typedef true_type IsMethod;

   explicit RunnableAdapter(R(T::*method)($for ARG , [[A$(ARG)]]) const)
       : method_(method) {
   }

   R Run(const T* object[[]]
 $if ARITY > 0[[, ]]  $for ARG, [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
     return (object->*method_)($for ARG , [[CallbackForward(a$(ARG))]]);
   }

  private:
   R (T::*method_)($for ARG , [[A$(ARG)]]) const;
 };

 ]]  $$ for ARITY


 // FunctionTraits<>
 //
 // Breaks a function signature apart into typedefs for easier introspection.
 template <typename Sig>
 struct FunctionTraits;

 $for ARITY [[
 $range ARG 1..ARITY

 template <typename R[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 struct FunctionTraits<R($for ARG , [[A$(ARG)]])> {
   typedef R ReturnType;
 $for ARG [[

   typedef A$(ARG) A$(ARG)Type;
 ]]

 };

 ]]


 // ForceVoidReturn<>
 //
 // Set of templates that support forcing the function return type to void.
 template <typename Sig>
 struct ForceVoidReturn;

 $for ARITY [[
 $range ARG 1..ARITY

 template <typename R[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 struct ForceVoidReturn<R($for ARG , [[A$(ARG)]])> {
   typedef void(RunType)($for ARG , [[A$(ARG)]]);
 };

 ]]  $$ for ARITY


 // FunctorTraits<>
 //
 // See description at top of file.
 template <typename T>
 struct FunctorTraits {
   typedef RunnableAdapter<T> RunnableType;
   typedef typename RunnableType::RunType RunType;
 };

 template <typename T>
 struct FunctorTraits<IgnoreResultHelper<T> > {
   typedef typename FunctorTraits<T>::RunnableType RunnableType;
   typedef typename ForceVoidReturn<
       typename RunnableType::RunType>::RunType RunType;
 };

 template <typename T>
 struct FunctorTraits<Callback<T> > {
   typedef Callback<T> RunnableType;
   typedef typename Callback<T>::RunType RunType;
 };


 // MakeRunnable<>
 //
 // Converts a passed in functor to a RunnableType using type inference.

 template <typename T>
 typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) {
   return RunnableAdapter<T>(t);
 }

 template <typename T>
 typename FunctorTraits<T>::RunnableType
 MakeRunnable(const IgnoreResultHelper<T>& t) {
   return MakeRunnable(t.functor_);
 }

 template <typename T>
 const typename FunctorTraits<Callback<T> >::RunnableType&
 MakeRunnable(const Callback<T>& t) {
   DCHECK(!t.is_null());
   return t;
 }


 // InvokeHelper<>
 //
 // There are 3 logical InvokeHelper<> specializations: normal, void-return,
 // WeakCalls.
 //
 // The normal type just calls the underlying runnable.
 //
 // We need a InvokeHelper to handle void return types in order to support
 // IgnoreResult().  Normally, if the Runnable's RunType had a void return,
 // the template system would just accept "return functor.Run()" ignoring
 // the fact that a void function is being used with return. This piece of
 // sugar breaks though when the Runnable's RunType is not void.  Thus, we
 // need a partial specialization to change the syntax to drop the "return"
 // from the invocation call.
 //
 // WeakCalls similarly need special syntax that is applied to the first
 // argument to check if they should no-op themselves.
 template <bool IsWeakCall, typename ReturnType, typename Runnable,
           typename ArgsType>
 struct InvokeHelper;

 $for ARITY [[
 $range ARG 1..ARITY
 $range WEAKCALL_ARG 2..ARITY

 template <typename ReturnType, typename Runnable[[]]
 $if ARITY > 0 [[,]] $for ARG , [[typename A$(ARG)]]>
 struct InvokeHelper<false, ReturnType, Runnable,
     void($for ARG , [[A$(ARG)]])>  {
   static ReturnType MakeItSo(Runnable runnable[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG) a$(ARG)]]) {
     return runnable.Run($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 };

 template <typename Runnable[[]]
 $if ARITY > 0 [[,]] $for ARG , [[typename A$(ARG)]]>
 struct InvokeHelper<false, void, Runnable,
     void($for ARG , [[A$(ARG)]])>  {
   static void MakeItSo(Runnable runnable[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG) a$(ARG)]]) {
     runnable.Run($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 };

 $if ARITY > 0 [[

 template <typename Runnable[[]], typename BoundWeakPtr
 $if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[typename A$(WEAKCALL_ARG)]]>
 struct InvokeHelper<true, void, Runnable,
     void(BoundWeakPtr
 $if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[A$(WEAKCALL_ARG)]])>  {
   static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr
 $if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[A$(WEAKCALL_ARG) a$(WEAKCALL_ARG)]]) {
     if (!weak_ptr.get()) {
       return;
     }
     runnable.Run(weak_ptr.get()
 $if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[CallbackForward(a$(WEAKCALL_ARG))]]);
   }
 };

 ]]

 ]] $$ for ARITY

 #if !defined(_MSC_VER)

 template <typename ReturnType, typename Runnable, typename ArgsType>
 struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
   // WeakCalls are only supported for functions with a void return type.
   // Otherwise, the function result would be undefined if the the WeakPtr<>
   // is invalidated.
   COMPILE_ASSERT(is_void<ReturnType>::value,
                  weak_ptrs_can_only_bind_to_methods_without_return_values);
 };

 #endif

 // Invoker<>
 //
 // See description at the top of the file.
 template <int NumBound, typename Storage, typename RunType>
 struct Invoker;

 $for ARITY [[

 $$ Number of bound arguments.
 $range BOUND 0..ARITY
 $for BOUND [[

 $var UNBOUND = ARITY - BOUND
 $range ARG 1..ARITY
 $range BOUND_ARG 1..BOUND
 $range UNBOUND_ARG (ARITY - UNBOUND + 1)..ARITY

 // Arity $(ARITY) -> $(UNBOUND).
 template <typename StorageType, typename R[[]]
 $if ARITY > 0 [[,]][[]]
 $for ARG , [[typename X$(ARG)]]>
 struct Invoker<$(BOUND), StorageType, R($for ARG , [[X$(ARG)]])> {
   typedef R(RunType)(BindStateBase*[[]]
 $if UNBOUND != 0 [[, ]]
 $for UNBOUND_ARG , [[typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType]]);

   typedef R(UnboundRunType)($for UNBOUND_ARG , [[X$(UNBOUND_ARG)]]);

   static R Run(BindStateBase* base[[]]
 $if UNBOUND != 0 [[, ]][[]]
 $for UNBOUND_ARG , [[
 typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType x$(UNBOUND_ARG)
 ]][[]]
 ) {
     StorageType* storage = static_cast<StorageType*>(base);

     // Local references to make debugger stepping easier. If in a debugger,
     // you really want to warp ahead and step through the
     // InvokeHelper<>::MakeItSo() call below.
 $for BOUND_ARG
 [[

     typedef typename StorageType::Bound$(BOUND_ARG)UnwrapTraits Bound$(BOUND_ARG)UnwrapTraits;
 ]]


 $for BOUND_ARG
 [[

     typename Bound$(BOUND_ARG)UnwrapTraits::ForwardType x$(BOUND_ARG) =
         Bound$(BOUND_ARG)UnwrapTraits::Unwrap(storage->p$(BOUND_ARG)_);
 ]]

     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(
 $for BOUND_ARG , [[
 typename Bound$(BOUND_ARG)UnwrapTraits::ForwardType
 ]]

 $if UNBOUND > 0 [[$if BOUND > 0 [[, ]]]][[]]

 $for UNBOUND_ARG , [[
 typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType x$(UNBOUND_ARG)
 ]]
 )>
                ::MakeItSo(storage->runnable_
 $if ARITY > 0[[, ]] $for ARG , [[CallbackForward(x$(ARG))]]);
   }
 };

 ]] $$ for BOUND
 ]] $$ for ARITY


 // BindState<>
 //
 // This stores all the state passed into Bind() and is also where most
 // of the template resolution magic occurs.
 //
 // Runnable is the functor we are binding arguments to.
 // RunType is type of the Run() function that the Invoker<> should use.
 // Normally, this is the same as the RunType of the Runnable, but it can
 // be different if an adapter like IgnoreResult() has been used.
 //
 // BoundArgsType contains the storage type for all the bound arguments by
 // (ab)using a function type.
 template <typename Runnable, typename RunType, typename BoundArgsType>
 struct BindState;

 $for ARITY [[
 $range ARG 1..ARITY

 template <typename Runnable, typename RunType[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename P$(ARG)]]>
 struct BindState<Runnable, RunType, void($for ARG , [[P$(ARG)]])> : public BindStateBase {
   typedef Runnable RunnableType;

 $if ARITY > 0 [[
   typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
 ]] $else [[
   typedef false_type IsWeakCall;
 ]]

   typedef Invoker<$(ARITY), BindState, RunType> InvokerType;
   typedef typename InvokerType::UnboundRunType UnboundRunType;

 $if ARITY > 0 [[

   // Convenience typedefs for bound argument types.

 $for ARG [[
   typedef UnwrapTraits<P$(ARG)> Bound$(ARG)UnwrapTraits;

 ]]  $$ for ARG


 ]]  $$ if ARITY > 0

 $$ The extra [[ ]] is needed to massage spacing. Silly pump.py.
 [[  ]]$if ARITY == 0 [[explicit ]]BindState(const Runnable& runnable
 $if ARITY > 0 [[, ]] $for ARG , [[const P$(ARG)& p$(ARG)]])
       : runnable_(runnable)[[]]
 $if ARITY == 0 [[
  {

 ]] $else [[
 , $for ARG , [[

         p$(ARG)_(p$(ARG))
 ]] {
     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);

 ]]
   }

   virtual ~BindState() {
 $if ARITY > 0 [[
     MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::Release(p1_);
 ]]
   }

   RunnableType runnable_;

 $for ARG [[
   P$(ARG) p$(ARG)_;

 ]]
 };

 ]] $$ for ARITY

 }  // namespace internal
 }  // namespace base

 #endif  // BASE_BIND_INTERNAL_H_
	$$ This is a pump file for generating file templates. Pump is a python
	$$ script that is part of the Google Test suite of utilities. Description
	$$ can be found here:
	$$
	$$ http://code.google.com/p/googletest/wiki/PumpManual
	$$

	$$ See comment for MAX_ARITY in base/bind.h.pump.
	$var MAX_ARITY = 7
	$range ARITY 0..MAX_ARITY

	// Copyright (c) 2011 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef BASE_BIND_INTERNAL_H_
	#define BASE_BIND_INTERNAL_H_

	#include "base/bind_helpers.h"
	#include "base/callback_internal.h"
	#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
	#include "base/memory/weak_ptr.h"
	#include "base/template_util.h"
	#include "build/build_config.h"

	#if defined(OS_WIN)
	#include "base/bind_internal_win.h"
	#endif

	namespace base {
	namespace internal {

	// See base/callback.h for user documentation.
	//
	//
	// CONCEPTS:
	// Runnable -- A type (really a type class) that has a single Run() method
	// and a RunType typedef that corresponds to the type of Run().
	// A Runnable can declare that it should treated like a method
	// call by including a typedef named IsMethod. The value of
	// this typedef is NOT inspected, only the existence. When a
	// Runnable declares itself a method, Bind() will enforce special
	// refcounting + WeakPtr handling semantics for the first
	// parameter which is expected to be an object.
	// Functor -- A copyable type representing something that should be called.
	// All function pointers, Callback<>, and Runnables are functors
	// even if the invocation syntax differs.
	// RunType -- A function type (as opposed to function _pointer_ type) for
	// a Run() function. Usually just a convenience typedef.
	// (Bound)ArgsType -- A function type that is being (ab)used to store the
	// types of set of arguments. The "return" type is always
	// void here. We use this hack so that we do not need
	// a new type name for each arity of type. (eg.,
	// BindState1, BindState2). This makes forward
	// declarations and friending much much easier.
	//
	// Types:
	// RunnableAdapter<> -- Wraps the various "function" pointer types into an
	// object that adheres to the Runnable interface.
	// There are \|3*ARITY\| RunnableAdapter types.
	// FunctionTraits<> -- Type traits that unwrap a function signature into a
	// a set of easier to use typedefs. Used mainly for
	// compile time asserts.
	// There are \|ARITY\| FunctionTraits types.
	// ForceVoidReturn<> -- Helper class for translating function signatures to
	// equivalent forms with a "void" return type.
	// There are \|ARITY\| ForceVoidReturn types.
	// FunctorTraits<> -- Type traits used determine the correct RunType and
	// RunnableType for a Functor. This is where function
	// signature adapters are applied.
	// There are \|ARITY\| ForceVoidReturn types.
	// MakeRunnable<> -- Takes a Functor and returns an object in the Runnable
	// type class that represents the underlying Functor.
	// There are \|O(1)\| MakeRunnable types.
	// InvokeHelper<> -- Take a Runnable + arguments and actully invokes it.
	// Handle the differing syntaxes needed for WeakPtr<> support,
	// and for ignoring return values. This is separate from
	// Invoker to avoid creating multiple version of Invoker<>
	// which grows at O(n^2) with the arity.
	// There are \|k*ARITY\| InvokeHelper types.
	// Invoker<> -- Unwraps the curried parameters and executes the Runnable.
	// There are \|(ARITY^2 + ARITY)/2\| Invoketypes.
	// BindState<> -- Stores the curried parameters, and is the main entry point
	// into the Bind() system, doing most of the type resolution.
	// There are ARITY BindState types.

	// RunnableAdapter<>
	//
	// The RunnableAdapter<> templates provide a uniform interface for invoking
	// a function pointer, method pointer, or const method pointer. The adapter
	// exposes a Run() method with an appropriate signature. Using this wrapper
	// allows for writing code that supports all three pointer types without
	// undue repetition. Without it, a lot of code would need to be repeated 3
	// times.
	//
	// For method pointers and const method pointers the first argument to Run()
	// is considered to be the received of the method. This is similar to STL's
	// mem_fun().
	//
	// This class also exposes a RunType typedef that is the function type of the
	// Run() function.
	//
	// If and only if the wrapper contains a method or const method pointer, an
	// IsMethod typedef is exposed. The existence of this typedef (NOT the value)
	// marks that the wrapper should be considered a method wrapper.

	template <typename Functor>
	class RunnableAdapter;

	$for ARITY [[
	$range ARG 1..ARITY

	// Function: Arity $(ARITY).
	template <typename R[[]]
	$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
	class RunnableAdapter<R(*)($for ARG , [[A$(ARG)]])> {
	public:
	typedef R (RunType)($for ARG , [[A$(ARG)]]);

	explicit RunnableAdapter(R(*function)($for ARG , [[A$(ARG)]]))
	: function_(function) {
	}

	R Run($for ARG , [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
	return function_($for ARG , [[CallbackForward(a$(ARG))]]);
	}

	private:
	R (*function_)($for ARG , [[A$(ARG)]]);
	};

	// Method: Arity $(ARITY).
	template <typename R, typename T[[]]
	$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
	class RunnableAdapter<R(T::*)($for ARG , [[A$(ARG)]])> {
	public:
	typedef R (RunType)(T*[[]]
	$if ARITY > 0[[, ]] $for ARG , [[A$(ARG)]]);
	typedef true_type IsMethod;

	explicit RunnableAdapter(R(T::*method)($for ARG , [[A$(ARG)]]))
	: method_(method) {
	}

	R Run(T* object[[]]
	$if ARITY > 0[[, ]] $for ARG, [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
	return (object->*method_)($for ARG , [[CallbackForward(a$(ARG))]]);
	}

	private:
	R (T::*method_)($for ARG , [[A$(ARG)]]);
	};

	// Const Method: Arity $(ARITY).
	template <typename R, typename T[[]]
	$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
	class RunnableAdapter<R(T::*)($for ARG , [[A$(ARG)]]) const> {
	public:
	typedef R (RunType)(const T*[[]]
	$if ARITY > 0[[, ]] $for ARG , [[A$(ARG)]]);
	typedef true_type IsMethod;

	explicit RunnableAdapter(R(T::*method)($for ARG , [[A$(ARG)]]) const)
	: method_(method) {
	}

	R Run(const T* object[[]]
	$if ARITY > 0[[, ]] $for ARG, [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
	return (object->*method_)($for ARG , [[CallbackForward(a$(ARG))]]);
	}

	private:
	R (T::*method_)($for ARG , [[A$(ARG)]]) const;
	};

	]] $$ for ARITY


	// FunctionTraits<>
	//
	// Breaks a function signature apart into typedefs for easier introspection.
	template <typename Sig>
	struct FunctionTraits;

	$for ARITY [[
	$range ARG 1..ARITY

	template <typename R[[]]
	$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
	struct FunctionTraits<R($for ARG , [[A$(ARG)]])> {
	typedef R ReturnType;
	$for ARG [[

	typedef A$(ARG) A$(ARG)Type;
	]]

	};

	]]


	// ForceVoidReturn<>
	//
	// Set of templates that support forcing the function return type to void.
	template <typename Sig>
	struct ForceVoidReturn;

	$for ARITY [[
	$range ARG 1..ARITY

	template <typename R[[]]
	$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
	struct ForceVoidReturn<R($for ARG , [[A$(ARG)]])> {
	typedef void(RunType)($for ARG , [[A$(ARG)]]);
	};

	]] $$ for ARITY


	// FunctorTraits<>
	//
	// See description at top of file.
	template <typename T>
	struct FunctorTraits {
	typedef RunnableAdapter<T> RunnableType;
	typedef typename RunnableType::RunType RunType;
	};

	template <typename T>
	struct FunctorTraits<IgnoreResultHelper<T> > {
	typedef typename FunctorTraits<T>::RunnableType RunnableType;
	typedef typename ForceVoidReturn<
	typename RunnableType::RunType>::RunType RunType;
	};

	template <typename T>
	struct FunctorTraits<Callback<T> > {
	typedef Callback<T> RunnableType;
	typedef typename Callback<T>::RunType RunType;
	};


	// MakeRunnable<>
	//
	// Converts a passed in functor to a RunnableType using type inference.

	template <typename T>
	typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) {
	return RunnableAdapter<T>(t);
	}

	template <typename T>
	typename FunctorTraits<T>::RunnableType
	MakeRunnable(const IgnoreResultHelper<T>& t) {
	return MakeRunnable(t.functor_);
	}

	template <typename T>
	const typename FunctorTraits<Callback<T> >::RunnableType&
	MakeRunnable(const Callback<T>& t) {
	DCHECK(!t.is_null());
	return t;
	}


	// InvokeHelper<>
	//
	// There are 3 logical InvokeHelper<> specializations: normal, void-return,
	// WeakCalls.
	//
	// The normal type just calls the underlying runnable.
	//
	// We need a InvokeHelper to handle void return types in order to support
	// IgnoreResult(). Normally, if the Runnable's RunType had a void return,
	// the template system would just accept "return functor.Run()" ignoring
	// the fact that a void function is being used with return. This piece of
	// sugar breaks though when the Runnable's RunType is not void. Thus, we
	// need a partial specialization to change the syntax to drop the "return"
	// from the invocation call.
	//
	// WeakCalls similarly need special syntax that is applied to the first
	// argument to check if they should no-op themselves.
	template <bool IsWeakCall, typename ReturnType, typename Runnable,
	typename ArgsType>
	struct InvokeHelper;

	$for ARITY [[
	$range ARG 1..ARITY
	$range WEAKCALL_ARG 2..ARITY

	template <typename ReturnType, typename Runnable[[]]
	$if ARITY > 0 [[,]] $for ARG , [[typename A$(ARG)]]>
	struct InvokeHelper<false, ReturnType, Runnable,
	void($for ARG , [[A$(ARG)]])> {
	static ReturnType MakeItSo(Runnable runnable[[]]
	$if ARITY > 0[[, ]] $for ARG , [[A$(ARG) a$(ARG)]]) {
	return runnable.Run($for ARG , [[CallbackForward(a$(ARG))]]);
	}
	};

	template <typename Runnable[[]]
	$if ARITY > 0 [[,]] $for ARG , [[typename A$(ARG)]]>
	struct InvokeHelper<false, void, Runnable,
	void($for ARG , [[A$(ARG)]])> {
	static void MakeItSo(Runnable runnable[[]]
	$if ARITY > 0[[, ]] $for ARG , [[A$(ARG) a$(ARG)]]) {
	runnable.Run($for ARG , [[CallbackForward(a$(ARG))]]);
	}
	};

	$if ARITY > 0 [[

	template <typename Runnable[[]], typename BoundWeakPtr
	$if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[typename A$(WEAKCALL_ARG)]]>
	struct InvokeHelper<true, void, Runnable,
	void(BoundWeakPtr
	$if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[A$(WEAKCALL_ARG)]])> {
	static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr
	$if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[A$(WEAKCALL_ARG) a$(WEAKCALL_ARG)]]) {
	if (!weak_ptr.get()) {
	return;
	}
	runnable.Run(weak_ptr.get()
	$if ARITY > 1[[, ]] $for WEAKCALL_ARG , [[CallbackForward(a$(WEAKCALL_ARG))]]);
	}
	};

	]]

	]] $$ for ARITY

	#if !defined(_MSC_VER)

	template <typename ReturnType, typename Runnable, typename ArgsType>
	struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
	// WeakCalls are only supported for functions with a void return type.
	// Otherwise, the function result would be undefined if the the WeakPtr<>
	// is invalidated.
	COMPILE_ASSERT(is_void<ReturnType>::value,
	weak_ptrs_can_only_bind_to_methods_without_return_values);
	};

	#endif

	// Invoker<>
	//
	// See description at the top of the file.
	template <int NumBound, typename Storage, typename RunType>
	struct Invoker;

	$for ARITY [[

	$$ Number of bound arguments.
	$range BOUND 0..ARITY
	$for BOUND [[

	$var UNBOUND = ARITY - BOUND
	$range ARG 1..ARITY
	$range BOUND_ARG 1..BOUND
	$range UNBOUND_ARG (ARITY - UNBOUND + 1)..ARITY

	// Arity $(ARITY) -> $(UNBOUND).
	template <typename StorageType, typename R[[]]
	$if ARITY > 0 [[,]][[]]
	$for ARG , [[typename X$(ARG)]]>
	struct Invoker<$(BOUND), StorageType, R($for ARG , [[X$(ARG)]])> {
	typedef R(RunType)(BindStateBase*[[]]
	$if UNBOUND != 0 [[, ]]
	$for UNBOUND_ARG , [[typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType]]);

	typedef R(UnboundRunType)($for UNBOUND_ARG , [[X$(UNBOUND_ARG)]]);

	static R Run(BindStateBase* base[[]]
	$if UNBOUND != 0 [[, ]][[]]
	$for UNBOUND_ARG , [[
	typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType x$(UNBOUND_ARG)
	]][[]]
	) {
	StorageType* storage = static_cast<StorageType*>(base);

	// Local references to make debugger stepping easier. If in a debugger,
	// you really want to warp ahead and step through the
	// InvokeHelper<>::MakeItSo() call below.
	$for BOUND_ARG
	[[

	typedef typename StorageType::Bound$(BOUND_ARG)UnwrapTraits Bound$(BOUND_ARG)UnwrapTraits;
	]]


	$for BOUND_ARG
	[[

	typename Bound$(BOUND_ARG)UnwrapTraits::ForwardType x$(BOUND_ARG) =
	Bound$(BOUND_ARG)UnwrapTraits::Unwrap(storage->p$(BOUND_ARG)_);
	]]

	return InvokeHelper<StorageType::IsWeakCall::value, R,
	typename StorageType::RunnableType,
	void(
	$for BOUND_ARG , [[
	typename Bound$(BOUND_ARG)UnwrapTraits::ForwardType
	]]

	$if UNBOUND > 0 [[$if BOUND > 0 [[, ]]]][[]]

	$for UNBOUND_ARG , [[
	typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType x$(UNBOUND_ARG)
	]]
	)>
	::MakeItSo(storage->runnable_
	$if ARITY > 0[[, ]] $for ARG , [[CallbackForward(x$(ARG))]]);
	}
	};

	]] $$ for BOUND
	]] $$ for ARITY


	// BindState<>
	//
	// This stores all the state passed into Bind() and is also where most
	// of the template resolution magic occurs.
	//
	// Runnable is the functor we are binding arguments to.
	// RunType is type of the Run() function that the Invoker<> should use.
	// Normally, this is the same as the RunType of the Runnable, but it can
	// be different if an adapter like IgnoreResult() has been used.
	//
	// BoundArgsType contains the storage type for all the bound arguments by
	// (ab)using a function type.
	template <typename Runnable, typename RunType, typename BoundArgsType>
	struct BindState;

	$for ARITY [[
	$range ARG 1..ARITY

	template <typename Runnable, typename RunType[[]]
	$if ARITY > 0[[, ]] $for ARG , [[typename P$(ARG)]]>
	struct BindState<Runnable, RunType, void($for ARG , [[P$(ARG)]])> : public BindStateBase {
	typedef Runnable RunnableType;

	$if ARITY > 0 [[
	typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
	]] $else [[
	typedef false_type IsWeakCall;
	]]

	typedef Invoker<$(ARITY), BindState, RunType> InvokerType;
	typedef typename InvokerType::UnboundRunType UnboundRunType;

	$if ARITY > 0 [[

	// Convenience typedefs for bound argument types.

	$for ARG [[
	typedef UnwrapTraits<P$(ARG)> Bound$(ARG)UnwrapTraits;

	]] $$ for ARG


	]] $$ if ARITY > 0

	$$ The extra [[ ]] is needed to massage spacing. Silly pump.py.
	[[ ]]$if ARITY == 0 [[explicit ]]BindState(const Runnable& runnable
	$if ARITY > 0 [[, ]] $for ARG , [[const P$(ARG)& p$(ARG)]])
	: runnable_(runnable)[[]]
	$if ARITY == 0 [[
	{

	]] $else [[
	, $for ARG , [[

	p$(ARG)_(p$(ARG))
	]] {
	MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);

	]]
	}

	virtual ~BindState() {
	$if ARITY > 0 [[
	MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::Release(p1_);
	]]
	}

	RunnableType runnable_;

	$for ARG [[
	P$(ARG) p$(ARG)_;

	]]
	};

	]] $$ for ARITY

	} // namespace internal
	} // namespace base

	#endif // BASE_BIND_INTERNAL_H_