| /* |
| * Copyright 2016 The WebRTC Project Authors. All rights reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #ifndef WEBRTC_BASE_FUNCTION_VIEW_H_ |
| #define WEBRTC_BASE_FUNCTION_VIEW_H_ |
| |
| #include <type_traits> |
| #include <utility> |
| |
| // Just like std::function, FunctionView will wrap any callable and hide its |
| // actual type, exposing only its signature. But unlike std::function, |
| // FunctionView doesn't own its callable---it just points to it. Thus, it's a |
| // good choice mainly as a function argument when the callable argument will |
| // not be called again once the function has returned. |
| // |
| // TODO(kwiberg): FunctionView doesn't work with function pointers, just with |
| // lambdas. It's trivial to work around this by wrapping the function pointer |
| // in a stateless lambda, but it's tedious so it'd be nice to not have to do |
| // it. |
| |
| namespace rtc { |
| |
| template <typename T> |
| class FunctionView; // Undefined. |
| |
| template <typename RetT, typename... ArgT> |
| class FunctionView<RetT(ArgT...)> final { |
| public: |
| // This constructor is implicit, so that callers won't have to convert |
| // lambdas and other callables to FunctionView<Blah(Blah, Blah)> explicitly. |
| // This is safe because FunctionView is only a reference to the real |
| // callable. |
| // |
| // We jump through some template metaprogramming hoops to ensure that this |
| // constructor does *not* accept FunctionView arguments. That way, copy |
| // construction, assignment, swap etc. will all do the obvious thing (because |
| // they use the implicitly-declared copy constructor and copy assignment), |
| // and we will never get a FunctionView object that points to another |
| // FunctionView. |
| template <typename F, |
| typename std::enable_if<!std::is_same< |
| FunctionView, |
| typename std::remove_cv<typename std::remove_reference< |
| F>::type>::type>::value>::type* = nullptr> |
| FunctionView(F&& f) |
| : f_(&f), call_(Call<typename std::remove_reference<F>::type>) {} |
| |
| RetT operator()(ArgT... args) const { |
| return call_(f_, std::forward<ArgT>(args)...); |
| } |
| |
| private: |
| template <typename F> |
| static RetT Call(void* f, ArgT... args) { |
| return (*static_cast<F*>(f))(std::forward<ArgT>(args)...); |
| } |
| void* f_; |
| RetT (*call_)(void* f, ArgT... args); |
| }; |
| |
| } // namespace rtc |
| |
| #endif // WEBRTC_BASE_FUNCTION_VIEW_H_ |