stdfunction的改进和可配置的直接替换，支持仅移动类型、多重重载等___下载.zip

# fu2::function an improved drop-in replacement to std::function   [](https://travis-ci.org/Naios/function2) [](https://ci.appveyor.com/project/Naios/function2/branch/master) Provides improved implementations of `std::function`: - **copyable** `fu2::function` - **move-only** `fu2::unique_function` (capable of holding move only types) - **non-owning** `fu2::function_view` (capable of referencing callables in a non owning way) that provide many benefits and improvements over `std::function`: - [x] **const**, **volatile**, **reference** and **noexcept** correct (qualifiers are part of the `operator()` signature) - [x] **convertible** to and from `std::function` as well as other callable types - [x] **adaptable** through `fu2::function_base` (internal capacity, copyable and exception guarantees) - [x] **overloadable** with an arbitrary count of signatures (`fu2::function<bool(int), bool(float)>`) - [x] **full allocator support** in contrast to `std::function`, which doesn't provide support anymore - [x] **covered** by many unit tests and continuous integration services (*GCC*, *Clang* and *MSVC*) - [x] **header only**, just copy and include `function.hpp` in your project - [x] **permissively licensed** under the **boost** license ## Table of Contents * **[Documentation](#documentation)** * **[How to use](#how-to-use)** * **[Constructing a function](#constructing-a-function)** * **[Non copyable unique functions](#non-copyable-unique-functions)** * **[Convertibility of functions](#convertibility-of-functions)** * **[Adapt function2](#adapt-function2)** * **[Performance and optimization](#performance-and-optimization)** * **[Small functor optimization](#small-functor-optimization)** * **[Compiler optimization](#compiler-optimization)** * **[std::function vs fu2::function](#stdfunction-vs-fu2function)** * **[Coverage and runtime checks](#coverage-and-runtime-checks)** * **[Compatibility](#compatibility)** * **[License](#licence)** * **[Similar implementations](#similar-implementations)** ## Documentation ### How to use **function2** is implemented in one header (`function.hpp`), no compilation is required. Just copy the `function.hpp` header in your project and include it to start. It's recommended to import the library as git submodule using CMake: ```sh # Shell: git submodule add https://github.com/Naios/function2.git ``` ```cmake # CMake file: add_subdirectory(function2) # function2 provides an interface target which makes it's # headers available to all projects using function2 target_link_libraries(my_project function2) ``` Use `fu2::function` as a wrapper for copyable function wrappers and `fu2::unique_function` for move only types. The standard implementation `std::function` and `fu2::function` are convertible to each other, see [the chapter convertibility of functions](#convertibility-of-functions) for details. A function wrapper is declared as following: ```c++ fu2::function<void(int, float) const> // Return type ~^ ^ ^ ^ // Parameters ~~~~~|~~~~~| ^ // Qualifier ~~~~~~~~~~~~~~~~~~~| ``` * **Return type**: The return type of the function to wrap. * **Arguments**: The argument types of the function to wrap. Any argument types are allowed. * **Qualifiers**: There are several qualifiers allowed: - **no qualifier** provides `ReturnType operator() (Args...)` - Can be assigned from const and no const objects (*mutable lambdas* for example). - **const** provides `ReturnType operator() (Args...) const` - Requires that the assigned functor is const callable (won't work with *mutable lambdas*), - **volatile** provides `ReturnType operator() (Args...) volatile` - Can only be assigned from volatile qualified functors. - **const volatile** provides `ReturnType operator() (Args...) const volatile` - Same as const and volatile together. - **r-value (one-shot) functions** `ReturnType operator() (Args...) &&` - one-shot functions which are invalidated after the first call (can be mixed with `const`, `volatile` and `noexcept`). Can only wrap callable objects which call operator is also qualified as `&&` (r-value callable). Normal (*C*) functions are considered to be r-value callable by default. - **noexcept functions** `ReturnType operator() (Args...) noexcept` - such functions are guaranteed not to throw an exception (can be mixed with `const`, `volatile` and `&&`). Can only wrap functions or callable objects which call operator is also qualified as `noexcept`. Requires enabled C++17 compilation to work (support is detected automatically). Empty function calls to such a wrapped function will lead to a call to `std::abort` regardless the wrapper is configured to support exceptions or not (see [adapt function2](#adapt-function2)). * **Multiple overloads**: The library is capable of providing multiple overloads: ```cpp fu2::function<int(std::vector<int> const&), int(std::set<int> const&) const> fn = [] (auto const& container) { return container.size()); }; ``` ### Constructing a function `fu2::function` and `fu2::unique_function` (non copyable) are easy to use: ```c++ fu2::function<void() const> fun = [] { // ... }; // fun provides void operator()() const now fun(); ``` ### Non copyable unique functions `fu2::unique_function` also works with non copyable functors/ lambdas. ```c++ fu2::unique_function<bool() const> fun = [ptr = std::make_unique<bool>(true)] { return *ptr; }; // unique functions are move only fu2::unique_function<bool() const> otherfun = std::move(fun): otherfun(); ``` ### Non owning functions A `fu2::function_view` can be used to create a non owning view on a persistent object. Note that the view is only valid as long as the object lives. ```c++ auto callable = [ptr = std::make_unique<bool>(true)] { return *ptr; }; fu2::function_view<bool() const> view(callable); ``` ### Convertibility of functions `fu2::function`, `fu2::unique_function` and `std::function` are convertible to each other when: - The return type and parameter type match. - The functions are both volatile or not. - The functions are const correct: - `noconst = const` - `const = const` - `noconst = noconst` - The functions are copyable correct when: - `unique = unique` - `unique = copyable` - `copyable = copyable` - The functions are reference correct when: - `lvalue = lvalue` - `lvalue = rvalue` - `rvalue = rvalue` - The functions are `noexcept` correct when: - `callable = callable` - `callable = noexcept callable ` - `noexcept callable = noexcept callable` | Convertibility from \ to | fu2::function | fu2::unique_function | std::function | | ------------------------ | ------------- | -------------------- | ------------- | | fu2::function | Yes | Yes | Yes | | fu2::unique_function | No | Yes | No | | std::function | Yes | Yes | Yes | ```c++ fu2::function<void()> fun = []{}; // OK std::function<void()> std_fun = fun; // OK fu2::unique_function<void()> un_fun = fun; // Error (non copyable -> copyable) fun = un_fun; // Error (non copyable -> copyable) fun = un_fun; ``` ### Adapt function2 function2 is adaptable through `fu2::function_base` which allows you to set: - **IsOwning**: defines whether the function owns its contained object - **Copyable:** defines if the function is copyable or not. - **Capacity:** defines the internal capacity used for [sfo optimization](#small-functor-optimization): ```cpp struct my_capacity { static constexpr std::size_t capacity = sizeof(my_type);