501 lines
15 KiB
Plaintext
501 lines
15 KiB
Plaintext
|
$$ 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_
|