core.h

#pragma once
 
#include <functional>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
 
#include <frozen/string.h>
 
namespace util {

bool almostEqual(double a, double b, double threshold = 1e-6);

template <typename K, typename V>
std::unordered_set<K> keySet(const std::unordered_map<K, V>& input) {
    std::unordered_set<K> output;
    std::transform(input.begin(), input.end(), std::inserter(output, output.end()),
                   [](auto pair) { return pair.first; });
    return output;
}

template <typename T>
std::string to_string(const T& val) {
    return std::to_string(val);
}

template <>
std::string to_string<bool>(const bool& val);

frozen::string freezeStr(const std::string& str);

template <typename T, typename U>
std::tuple<T, U> pairToTuple(const std::pair<T, U>& pair) {
    return std::tuple<T, U>(pair.first, pair.second);
}

class RAIIHelper {
public:
    RAIIHelper(const std::function<void()>& f);
 
    RAIIHelper(const RAIIHelper&) = delete;

    RAIIHelper(RAIIHelper&& other);
 
    RAIIHelper& operator=(const RAIIHelper&) = delete;

    ~RAIIHelper();
 
private:
    std::function<void()> f;
};
 
} // namespace util