Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// Defines class CachedFunction
       6              : 
       7              : #pragma once
       8              : 
       9              : #include <type_traits>
      10              : #include <unordered_map>
      11              : #include <utility>
      12              : 
      13              : /// A function wrapper that caches function values.
      14              : template <typename Function, typename Map>
      15            1 : class CachedFunction {
      16              :  public:
      17            0 :   using input = typename Map::key_type;
      18            0 :   using output = typename Map::mapped_type;
      19              : 
      20              :   template <typename... MapArgs>
      21            0 :   explicit CachedFunction(Function function, MapArgs... map_args)
      22              :       : function_(std::move(function)),
      23              :         cache_(std::forward<MapArgs>(map_args)...) {}
      24              : 
      25              :   /// Obtain the function result
      26            1 :   const output& operator()(const input& x) {
      27              :     auto it = cache_.find(x);
      28              :     if (it == cache_.end()) {
      29              :       it = cache_.emplace(x, function_(x)).first;
      30              :     }
      31              :     return it->second;
      32              :   }
      33              : 
      34              :   /// Clear the cache entries
      35            1 :   void clear() { cache_.clear(); }
      36              : 
      37              :  private:
      38            0 :   Function function_;
      39            0 :   Map cache_;
      40              : };
      41              : 
      42              : /// Construct a CachedFunction wrapping the given function
      43              : ///
      44              : /// \example
      45              : /// \snippet Test_CachedFunction.cpp make_cached_function_example
      46              : ///
      47              : /// \tparam Input function argument type
      48              : /// \tparam Map class template to use as the map holding the cache
      49              : /// \param function the function
      50              : /// \param map_args arguments to pass to the map constructor
      51              : template <typename Input, template <typename...> class Map = std::unordered_map,
      52              :           typename... MapArgs, typename Function, typename... PassedMapArgs>
      53            1 : auto make_cached_function(Function function, PassedMapArgs... map_args) {
      54              :   using output = std::invoke_result_t<Function&, const Input&>;
      55              :   return CachedFunction<Function, Map<std::decay_t<Input>,
      56              :                                       std::decay_t<output>,
      57              :                                       MapArgs...>>(
      58              :       std::move(function), std::forward<PassedMapArgs>(map_args)...);
      59              : }