Functional.h

浏览该文件的文档.

// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma
// de Barcelona (UAB).
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include <utility>
 
namespace carla {
 
  class Functional {
  public:
 
    /// Creates a recursive callable object, where the itself is passed as first
    /// argument to @a func. Use case: create recursive lambda.
    template <typename FuncT>
    static auto MakeRecursive(FuncT &&func) {
      return Recursive<FuncT>(std::forward<FuncT>(func));
    }
 
    /// Creates an "overloaded callable object" out of one or more callable
    /// objects, each callable object will contribute with an overload of
    /// operator(). Use case: combine several lambdas into a single lambda.
    template <typename... FuncTs>
    static auto MakeOverload(FuncTs &&... fs) {
      return Overload<FuncTs...>(std::forward<FuncTs>(fs)...);
    }
 
    /// @see MakeRecursive and MakeOverload.
    template <typename... FuncTs>
    static auto MakeRecursiveOverload(FuncTs &&... fs) {
      return MakeRecursive(MakeOverload(std::forward<FuncTs>(fs)...));
    }
 
  private:
 
    template <typename... Ts>
    struct Overload;
 
    template <typename T, typename... Ts>
    struct Overload<T, Ts...> : T, Overload<Ts...> {
      Overload(T &&func, Ts &&... rest)
        : T(std::forward<T>(func)),
          Overload<Ts...>(std::forward<Ts>(rest)...) {}
 
      using T::operator();
 
      using Overload<Ts...>::operator();
    };
 
    template <typename T>
    struct Overload<T> : T {
      Overload(T &&func) : T(std::forward<T>(func)) {}
 
      using T::operator();
    };
 
    template<typename T>
    struct Recursive {
 
      explicit Recursive(T &&func) : _func(std::forward<T>(func)) {}
 
      template<typename... Ts>
      auto operator()(Ts &&... arguments) const {
        return _func(*this, std::forward<Ts>(arguments)...);
      }
 
    private:
 
      T _func;
    };
 
  };
 
} // namespace carla