multi_invoke.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2021 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
 
#ifndef MULTI_INVOKE_HPP
#define MULTI_INVOKE_HPP
#ifdef __cplusplus
#include <map>
#include <vector>
template<typename key, typename... function_args> class multi_invoke
{
  public:
  typedef void (*callback_type_t)(function_args...);
  void operator()(key k, function_args... args) const
  {
    std::vector<callback_type_t> funcs;
    // find all entries that match the key
    auto range = callbacks.equal_range(k);
    // to protect against the case where the callback modifies the list
    // cache the result
    for (auto i = range.first; i != range.second; i++) {
      funcs.push_back((*i).second);
    }
    for (auto cb: funcs) {
      cb(args...);
    }
  }
 
  void add(key k, callback_type_t cb)
  {
    // Prevent inserting same node/callback pair several times
    auto range = callbacks.equal_range(k);
    for (auto it = range.first; it != range.second; ++it) {
      if (it->second == cb) {
        return;
      }
    }
 
    callbacks.insert(std::make_pair(k, cb));
  }
 
  void remove(key k, callback_type_t cb)
  {
    auto range = callbacks.equal_range(k);
    for (auto it = range.first; it != range.second; ++it) {
      if (it->second == cb) {
        callbacks.erase(it);
        break;
      }
    }
  }
 
  bool contains(key k) const
  {
    return callbacks.count(k) > 0;
  }
 
  void erase(key k)
  {
    callbacks.erase(k);
  }
 
  void clear()
  {
    callbacks.clear();
  }
 
  bool empty() const
  {
    return callbacks.empty();
  }
 
  private:
  std::multimap<key, callback_type_t> callbacks;
};
 
#endif  // __cplusplus
 
#endif  //MULTI_INVOKE_HPP