CollectionConcepts.hpp

Go to the documentation of this file.

#pragma once
#include <ranges>
#include <concepts>
#include <vector>
#include <unordered_set>
 
namespace fishnet::util{
template<auto C, typename T>
concept Satisfies = requires {
    C.template operator()<T>();
};
 
template<typename R,typename T>
concept range_of = std::ranges::range<R> && std::convertible_to<std::ranges::range_value_t<R>,T>;
 
template<typename R, auto C>
concept range_over = std::ranges::range<R> && Satisfies<C,std::ranges::range_value_t<R>>;
 
template<typename R,typename T>
concept forward_range_of = std::ranges::forward_range<R> && range_of<R,T>;
 
template<typename R, auto C>
concept forward_range_over = std::ranges::forward_range<R> && range_over<R,C>;
 
template<typename R, typename T>
concept input_range_of = std::ranges::input_range<R> && range_of<R,T>;
 
template<typename R,auto C>
concept input_range_over = std::ranges::input_range<R> && range_over<R,C>;
 
template<typename R, typename T>
concept random_access_range_of = std::ranges::random_access_range<R> && range_of<R,T>;
 
template<typename R, auto C>
concept random_access_range_over = std::ranges::random_access_range<R> && range_over<R,C>;
 
template<typename V, typename T>
concept view_of = std::ranges::view<V> && range_of<V,T>;
 
template<typename V, auto C>
concept view_over = std::ranges::view<V> && range_over<V,C>;
 
constexpr size_t size(std::ranges::range auto && range) noexcept{
    using R = std::remove_cvref_t<decltype(range)>;
    if constexpr(std::ranges::sized_range<R>){
        return static_cast<size_t>(std::ranges::size(range));
    }else {
        return static_cast<size_t>(std::ranges::distance(range));
    }
}
 
constexpr inline bool isEmpty(std::ranges::range auto && range) noexcept {
    return size(range) == 0;
}
 
template<std::ranges::range R>
constexpr auto toVector(R&& range) {
    std::vector<std::ranges::range_value_t<R>> vec;
    for (auto&& elem : range) {
        vec.push_back(std::forward<decltype(elem)>(elem));
    }
    return vec;
}
 
template<std::ranges::range R>
constexpr auto toUnorderedSet(R&& range) {
    std::unordered_set<std::ranges::range_value_t<R>> set;
    for (auto&& elem : range) {
        set.insert(std::forward<decltype(elem)>(elem));
    }
    return set;
}
} // fishnet::util