Utils.hpp

Go to the documentation of this file.

#ifndef NAIA_UTILS_HPP
#define NAIA_UTILS_HPP

// our headers
#include "Utility/Logging/Logging.h"

// c++ headers
#include <map>
#include <vector>

namespace NAIA {

namespace _private {

// NOTE: this is a neat trick to have a piece of code only called N times, regardless of which thread calls it and when
// credits: https://twitter.com/The_Whole_Daisy/status/1450911231959703559?s=20&t=K4-GOLFtd-2kJoRn7hMxdA
template <unsigned int times_to_run> struct LimitedWarning {
  struct NotDonePrintingException {};

  LimitedWarning(std::string message, std::string source) : msg{std::move(message)}, src{std::move(source)} {}

  void operator()() const {
    try {
      static bool unused = [this] {
        static int count = 0;
        static auto logger = getLogger(src);

        logger->warn("{}", msg);
        if (++count < times_to_run - 1) {
          throw NotDonePrintingException{};
        }
        if (count == times_to_run - 1) {
          logger->warn("{} (This warning will not be printed anymore)", msg);
        }
        return true;
      }();
      (void)unused;
    } catch (const NotDonePrintingException &) {
    }
  }

  std::string msg;
  std::string src;
};

// NOTE(vformato): This will become inline in c++17
extern const LimitedWarning<10> keyexists_deprecation_msg;
} // namespace _private

template <typename T, typename Key, typename Value>
typename std::enable_if<std::is_convertible<T, Key>::value, bool>::type
KeyExists(T key, const std::map<Key, Value> &container) {
  _private::keyexists_deprecation_msg();
  return container.find(static_cast<Key>(key)) != end(container);
}

template <typename T, typename Value>
typename std::enable_if<std::is_convertible<T, size_t>::value, bool>::type
KeyExists(T key, const std::vector<Value> &container) {
  _private::keyexists_deprecation_msg();
  return container.size() > static_cast<size_t>(key);
}

template <typename T, typename Key, typename Value>
typename std::enable_if<std::is_convertible<T, Key>::value, bool>::type
ContainsKeys(const std::map<Key, Value> &container, T key) {
  return container.find(static_cast<Key>(key)) != end(container);
}

template <typename T, typename Key>
typename std::enable_if<std::is_convertible<Key, size_t>::value, bool>::type
ContainsKeys(const std::vector<T> &container, Key key) {
  return container.size() > static_cast<size_t>(key);
}

template <typename T, typename Key, typename... Keys, typename Value>
typename std::enable_if<std::is_convertible<T, Key>::value, bool>::type
ContainsKeys(const std::map<Key, Value> &container, T key, Keys... keys) {
  if (container.find(static_cast<Key>(key)) != end(container)) {
    return ContainsKeys(container.at(key), keys...);
  }

  return false;
}

template <typename T, typename Key, typename... Keys>
typename std::enable_if<std::is_convertible<Key, size_t>::value, bool>::type
ContainsKeys(const std::vector<T> &container, Key key, Keys... keys) {
  if (container.size() > static_cast<size_t>(key))
    return ContainsKeys(container[key], keys...);

  return false;
}

} // namespace NAIA
#endif