utils.hxx

Go to the documentation of this file.

#pragma once
 
// C++
#include <cstddef>
#include <functional>
#include <map>
#include <ostream>
#include <type_traits>
#include <variant>
#include <vector>
 
namespace cosmos {
 
 
template <typename _, bool def>
class NamedBool {
public:
        explicit NamedBool(bool val=def) :
                m_val{val} {}
 
        operator bool() const { return m_val; }
 
        void flip() {
                m_val = !m_val;
        }
protected:
        bool m_val = def;
};
 
 
template <typename R>
class ResourceGuard {
public: // types
 
        using CleanFunc = void (R);
 
public: // functions
 
        ResourceGuard(const ResourceGuard &) = delete;
        ResourceGuard& operator=(const ResourceGuard &) = delete;
 
        ResourceGuard(R r, std::function<CleanFunc> cleaner) :
                m_res{r},
                m_cleaner{cleaner}
        {}
 
        ~ResourceGuard() {
                if (!m_disarmed) {
                        m_cleaner(m_res);
                }
        }
 
        void disarm() { m_disarmed = true; }
 
protected: // data
 
        bool m_disarmed = false;
        R m_res;
        std::function<CleanFunc> m_cleaner;
};
 
template<typename T>
struct Identity { using type = T; };
 
template<typename T>
using IdentityT = typename Identity<T>::type;
 
// the stunt with IdentityT is required to avoid deduction problems when e.g.
// literal integer constants are involved.
template <typename T1>
bool in_range(const T1 &v, const IdentityT<T1> &_min, const IdentityT<T1> &_max) {
        return _min <= v && v <= _max;
}
 
template <typename T>
bool in_list(const T &v, const std::initializer_list<T> &l) {
        for (const auto &cmp: l) {
                if (v == cmp)
                        return true;
        }
 
        return false;
}
 
template <typename T>
constexpr size_t num_elements(const T &v) {
        return sizeof(v) / sizeof(v[0]);
}
 
template <typename T1, typename T2>
T1& append(T1 &v1, const T2 &v2) {
        v1.insert(std::end(v1), std::begin(v2), std::end(v2));
        return v1;
}
 
template<typename ENUM>
constexpr auto to_integral(const ENUM e) -> typename std::underlying_type<ENUM>::type {
        return static_cast<typename std::underlying_type<ENUM>::type>(e);
}
 
template<typename ENUM>
auto to_raw_ptr(ENUM *e) {
        using UT = typename std::underlying_type<ENUM>::type;
        return reinterpret_cast<UT*>(e);
}
 
template <typename VARIANT>
bool is_empty_variant(const VARIANT &var) {
        return std::holds_alternative<std::monostate>(var);
}
 
template <typename VARIANT>
bool variant_holds_value(const VARIANT &var) {
        return !is_empty_variant(var);
}
 
 
class Twice {};
 
class TwiceIterator {
public: // functions
 
        auto& operator++() {
                m_iterations++;
                return *this;
        }
 
        Twice operator*() {
                return Twice{};
        }
 
        bool operator==(const TwiceIterator o) const {
                return m_iterations == o.m_iterations;
        }
 
        bool operator!=(const TwiceIterator o) const {
                return !(*this == o);
        }
 
public: // data
        size_t m_iterations = 0;
};
 
inline TwiceIterator begin(Twice &) {
        return TwiceIterator{};
}
 
inline TwiceIterator end(Twice &) {
        return TwiceIterator{2};
}
 
} // end ns
 
template <typename T>
inline std::ostream& operator<<(std::ostream &o, const std::vector<T> &sv) {
        for (auto it = sv.begin(); it != sv.end(); it++) {
                if (it != sv.begin())
                        o << ", ";
                o << *it;
        }
 
        return o;
}
 
template <typename K, typename V>
inline std::ostream& operator<<(std::ostream &o, const std::map<K,V> &m) {
        for (auto it: m) {
                o << it.first << ": " << it.second << "\n";
        }
 
        return o;
}