X-Git-Url: http://plrg.eecs.uci.edu/git/?p=folly.git;a=blobdiff_plain;f=folly%2FFunction.h;h=8cff8d8bb6b519e045c837f67462e10766ba46a6;hp=9d9403ba992ceb1d5bc7108d7fec8dcca15ae6be;hb=86617507c88ebb628b8d292903edacd40e77ab13;hpb=996d59be509226b2a5ecbb7fe3205ace7cd734a3 diff --git a/folly/Function.h b/folly/Function.h index 9d9403ba..8cff8d8b 100644 --- a/folly/Function.h +++ b/folly/Function.h @@ -1,7 +1,5 @@ /* - * Copyright 2016 Facebook, Inc. - * - * @author Eric Niebler (eniebler@fb.com), Sven Over (over@fb.com) + * Copyright 2017-present Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +12,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * + */ +/* + * @author Eric Niebler (eniebler@fb.com), Sven Over (over@fb.com) * Acknowledgements: Giuseppe Ottaviano (ott@fb.com) */ @@ -225,6 +225,8 @@ #include #include +#include +#include namespace folly { @@ -242,19 +244,25 @@ enum class Op { MOVE, NUKE, FULL, HEAP }; union Data { void* big; - std::aligned_storage<6 * sizeof(void*)>::type small; + std::aligned_storage<6 * sizeof(void*)>::type tiny; }; -template ::type> -using IsSmall = std::integral_constant< - bool, - (sizeof(FunT) <= sizeof(Data::small) && - // Same as is_nothrow_move_constructible, but w/ no template instantiation. - noexcept(FunT(std::declval())) - )>; +template +using IsSmall = Conjunction< + std::integral_constant, + std::is_nothrow_move_constructible>; using SmallTag = std::true_type; using HeapTag = std::false_type; +template +struct NotFunction : std::true_type {}; +template +struct NotFunction> : std::false_type {}; + +template +using EnableIfNotFunction = + typename std::enable_if::value>::type; + struct CoerceTag {}; template @@ -288,7 +296,7 @@ struct FunctionTraits { template static ReturnType callSmall(Data& p, Args&&... args) { return static_cast((*static_cast( - static_cast(&p.small)))(static_cast(args)...)); + static_cast(&p.tiny)))(static_cast(args)...)); } template @@ -302,12 +310,16 @@ struct FunctionTraits { } ReturnType operator()(Args... args) { - auto& fn = *static_cast*>(this); + auto& fn = *static_cast*>(this); return fn.call_(fn.data_, static_cast(args)...); } - struct SharedFunctionImpl { - std::shared_ptr> sp_; + class SharedProxy { + std::shared_ptr> sp_; + + public: + explicit SharedProxy(Function&& func) + : sp_(std::make_shared>(std::move(func))) {} ReturnType operator()(Args&&... args) const { return (*sp_)(static_cast(args)...); } @@ -329,7 +341,7 @@ struct FunctionTraits { template static ReturnType callSmall(Data& p, Args&&... args) { return static_cast((*static_cast( - static_cast(&p.small)))(static_cast(args)...)); + static_cast(&p.tiny)))(static_cast(args)...)); } template @@ -343,12 +355,16 @@ struct FunctionTraits { } ReturnType operator()(Args... args) const { - auto& fn = *static_cast*>(this); + auto& fn = *static_cast*>(this); return fn.call_(fn.data_, static_cast(args)...); } - struct SharedFunctionImpl { - std::shared_ptr> sp_; + class SharedProxy { + std::shared_ptr> sp_; + + public: + explicit SharedProxy(Function&& func) + : sp_(std::make_shared>(std::move(func))) {} ReturnType operator()(Args&&... args) const { return (*sp_)(static_cast(args)...); } @@ -359,11 +375,11 @@ template bool execSmall(Op o, Data* src, Data* dst) { switch (o) { case Op::MOVE: - ::new (static_cast(&dst->small)) - Fun(std::move(*static_cast(static_cast(&src->small)))); + ::new (static_cast(&dst->tiny)) + Fun(std::move(*static_cast(static_cast(&src->tiny)))); FOLLY_FALLTHROUGH; case Op::NUKE: - static_cast(static_cast(&src->small))->~Fun(); + static_cast(static_cast(&src->tiny))->~Fun(); break; case Op::FULL: return true; @@ -393,9 +409,6 @@ bool execBig(Op o, Data* src, Data* dst) { } // namespace function } // namespace detail -FOLLY_PUSH_WARNING -FOLLY_MSVC_DISABLE_WARNING(4521) // Multiple copy constructors -FOLLY_MSVC_DISABLE_WARNING(4522) // Multiple assignment operators template class Function final : private detail::function::FunctionTraits { // These utility types are defined outside of the template to reduce @@ -414,8 +427,6 @@ class Function final : private detail::function::FunctionTraits { template using IsSmall = detail::function::IsSmall; - using OtherSignature = typename Traits::OtherSignature; - // The `data_` member is mutable to allow `constCastFunction` to work without // invoking undefined behavior. Const-correctness is only violated when // `FunctionType` is a const function type (e.g., `int() const`) and `*this` @@ -427,13 +438,13 @@ class Function final : private detail::function::FunctionTraits { friend Traits; friend Function folly::constCastFunction<>( Function&&) noexcept; - friend class Function; + friend class Function; template Function(Fun&& fun, SmallTag) noexcept { using FunT = typename std::decay::type; if (!detail::function::isNullPtrFn(fun)) { - ::new (static_cast(&data_.small)) FunT(static_cast(fun)); + ::new (static_cast(&data_.tiny)) FunT(static_cast(fun)); call_ = &Traits::template callSmall; exec_ = &detail::function::execSmall; } @@ -447,7 +458,13 @@ class Function final : private detail::function::FunctionTraits { exec_ = &detail::function::execBig; } - Function(Function&& that, CoerceTag) noexcept { + template + Function(Function&& that, CoerceTag) + : Function(static_cast&&>(that), HeapTag{}) {} + + Function( + Function&& that, + CoerceTag) noexcept { that.exec_(Op::MOVE, &that.data_, &data_); std::swap(call_, that.call_); std::swap(exec_, that.exec_); @@ -460,13 +477,14 @@ class Function final : private detail::function::FunctionTraits { Function() = default; // not copyable - // NOTE: Deleting the non-const copy constructor is unusual but necessary to - // prevent copies from non-const `Function` object from selecting the - // perfect forwarding implicit converting constructor below - // (i.e., `template Function(Fun&&)`). - Function(Function&) = delete; Function(const Function&) = delete; +#if __OBJC__ + // Delete conversion from Objective-C blocks + template + Function(ReturnType (^)(Args...)) = delete; +#endif + /** * Move constructor */ @@ -482,32 +500,46 @@ class Function final : private detail::function::FunctionTraits { /* implicit */ Function(std::nullptr_t) noexcept {} /** - * Constructs a new `Function` from any callable object. This - * handles function pointers, pointers to static member functions, - * `std::reference_wrapper` objects, `std::function` objects, and arbitrary - * objects that implement `operator()` if the parameter signature - * matches (i.e. it returns R when called with Args...). - * For a `Function` with a const function type, the object must be - * callable from a const-reference, i.e. implement `operator() const`. - * For a `Function` with a non-const function type, the object will - * be called from a non-const reference, which means that it will execute - * a non-const `operator()` if it is defined, and falls back to - * `operator() const` otherwise. + * Constructs a new `Function` from any callable object that is _not_ a + * `folly::Function`. This handles function pointers, pointers to static + * member functions, `std::reference_wrapper` objects, `std::function` + * objects, and arbitrary objects that implement `operator()` if the parameter + * signature matches (i.e. it returns an object convertible to `R` when called + * with `Args...`). * * \note `typename = ResultOf` prevents this overload from being * selected by overload resolution when `fun` is not a compatible function. + * + * \note The noexcept requires some explanation. IsSmall is true when the + * decayed type fits within the internal buffer and is noexcept-movable. But + * this ctor might copy, not move. What we need here, if this ctor does a + * copy, is that this ctor be noexcept when the copy is noexcept. That is not + * checked in IsSmall, and shouldn't be, because once the Function is + * constructed, the contained object is never copied. This check is for this + * ctor only, in the case that this ctor does a copy. */ - template > - /* implicit */ Function(Fun&& fun) noexcept(IsSmall::value) + template < + typename Fun, + typename = detail::function::EnableIfNotFunction, + typename = typename Traits::template ResultOf> + /* implicit */ Function(Fun fun) noexcept( + IsSmall::value && noexcept(Fun(std::declval()))) : Function(static_cast(fun), IsSmall{}) {} /** - * For moving a `Function` into a `Function`. + * For move-constructing from a `folly::Function`. + * For a `Function` with a `const` function type, the object must be + * callable from a `const`-reference, i.e. implement `operator() const`. + * For a `Function` with a non-`const` function type, the object will + * be called from a non-const reference, which means that it will execute + * a non-const `operator()` if it is defined, and falls back to + * `operator() const` otherwise. */ template < - bool Const = Traits::IsConst::value, - typename std::enable_if::type = 0> - Function(Function&& that) noexcept + typename Signature, + typename = typename Traits::template ResultOf>> + Function(Function&& that) noexcept( + noexcept(Function(std::move(that), CoerceTag{}))) : Function(std::move(that), CoerceTag{}) {} /** @@ -530,22 +562,33 @@ class Function final : private detail::function::FunctionTraits { exec_(Op::NUKE, &data_, nullptr); } - Function& operator=(Function&) = delete; Function& operator=(const Function&) = delete; +#if __OBJC__ + // Delete conversion from Objective-C blocks + template + Function& operator=(ReturnType (^)(Args...)) = delete; +#endif + /** * Move assignment operator + * + * \note Leaves `that` in a valid but unspecified state. If `&that == this` + * then `*this` is left in a valid but unspecified state. */ Function& operator=(Function&& that) noexcept { - if (&that != this) { - // Q: Why is is safe to destroy and reconstruct this object in place? - // A: Two reasons: First, `Function` is a final class, so in doing this - // we aren't slicing off any derived parts. And second, the move - // operation is guaranteed not to throw so we always leave the object - // in a valid state. - this->~Function(); - ::new (this) Function(std::move(that)); - } + // Q: Why is it safe to destroy and reconstruct this object in place? + // A: Two reasons: First, `Function` is a final class, so in doing this + // we aren't slicing off any derived parts. And second, the move + // operation is guaranteed not to throw so we always leave the object + // in a valid state. + // In the case of self-move (this == &that), this leaves the object in + // a default-constructed state. First the object is destroyed, then we + // pass the destroyed object to the move constructor. The first thing the + // move constructor does is default-construct the object. That object is + // "moved" into itself, which is a no-op for a default-constructed Function. + this->~Function(); + ::new (this) Function(std::move(that)); return *this; } @@ -556,8 +599,8 @@ class Function final : private detail::function::FunctionTraits { * \note `typename = ResultOf` prevents this overload from being * selected by overload resolution when `fun` is not a compatible function. */ - template > - Function& operator=(Fun&& fun) noexcept( + template ()))> + Function& operator=(Fun fun) noexcept( noexcept(/* implicit */ Function(std::declval()))) { // Doing this in place is more efficient when we can do so safely. if (noexcept(/* implicit */ Function(std::declval()))) { @@ -572,6 +615,17 @@ class Function final : private detail::function::FunctionTraits { return *this; } + /** + * For assigning from a `Function`. + */ + template < + typename Signature, + typename = typename Traits::template ResultOf>> + Function& operator=(Function&& that) noexcept( + noexcept(Function(std::move(that)))) { + return (*this = Function(std::move(that))); + } + /** * Clears this `Function`. */ @@ -621,17 +675,25 @@ class Function final : private detail::function::FunctionTraits { return exec_(Op::HEAP, nullptr, nullptr); } + using typename Traits::SharedProxy; + + /** + * Move this `Function` into a copyable callable object, of which all copies + * share the state. + */ + SharedProxy asSharedProxy() && { + return SharedProxy{std::move(*this)}; + } + /** * Construct a `std::function` by moving in the contents of this `Function`. * Note that the returned `std::function` will share its state (i.e. captured * data) across all copies you make of it, so be very careful when copying. */ std::function asStdFunction() && { - using Impl = typename Traits::SharedFunctionImpl; - return Impl{std::make_shared(std::move(*this))}; + return std::move(*this).asSharedProxy(); } }; -FOLLY_POP_WARNING template void swap(Function& lhs, Function& rhs) noexcept { @@ -674,4 +736,102 @@ Function constCastFunction( Function&& that) noexcept { return std::move(that); } + +namespace detail { +namespace function { +template +struct IsCallableAsImpl : std::false_type {}; + +template +struct IsCallableAsImpl< + Fun, + ReturnType(Args...), + void_t::type>> + : std::is_convertible< + typename std::result_of::type, + ReturnType> {}; + +template +struct IsCallableAs : IsCallableAsImpl {}; +} +} + +/** + * @class FunctionRef + * + * @brief A reference wrapper for callable objects + * + * FunctionRef is similar to std::reference_wrapper, but the template parameter + * is the function signature type rather than the type of the referenced object. + * A folly::FunctionRef is cheap to construct as it contains only a pointer to + * the referenced callable and a pointer to a function which invokes the + * callable. + * + * The user of FunctionRef must be aware of the reference semantics: storing a + * copy of a FunctionRef is potentially dangerous and should be avoided unless + * the referenced object definitely outlives the FunctionRef object. Thus any + * function that accepts a FunctionRef parameter should only use it to invoke + * the referenced function and not store a copy of it. Knowing that FunctionRef + * itself has reference semantics, it is generally okay to use it to reference + * lambdas that capture by reference. + */ + +template +class FunctionRef; + +template +class FunctionRef final { + using Call = ReturnType (*)(void*, Args&&...); + + static ReturnType uninitCall(void*, Args&&...) { + throw std::bad_function_call(); + } + + template + static ReturnType call(void* object, Args&&... args) { + using Pointer = _t>; + return static_cast(invoke( + static_cast(*static_cast(object)), + static_cast(args)...)); + } + + void* object_{nullptr}; + Call call_{&FunctionRef::uninitCall}; + + public: + /** + * Default constructor. Constructs an empty FunctionRef. + * + * Invoking it will throw std::bad_function_call. + */ + FunctionRef() = default; + + /** + * Construct a FunctionRef from a reference to a callable object. + */ + template < + typename Fun, + typename std::enable_if< + Conjunction< + Negation>>>, + detail::function::IsCallableAs>::value, + int>::type = 0> + constexpr /* implicit */ FunctionRef(Fun&& fun) noexcept + // `Fun` may be a const type, in which case we have to do a const_cast + // to store the address in a `void*`. This is safe because the `void*` + // will be cast back to `Fun*` (which is a const pointer whenever `Fun` + // is a const type) inside `FunctionRef::call` + : object_( + const_cast(static_cast(std::addressof(fun)))), + call_(&FunctionRef::call) {} + + ReturnType operator()(Args... args) const { + return call_(object_, static_cast(args)...); + } + + constexpr explicit operator bool() const { + return object_; + } +}; + } // namespace folly