Queryable.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_QUERY_CONCEPTS_QUERYABLE_HPP_
#define ECSTASY_QUERY_CONCEPTS_QUERYABLE_HPP_
 
#include <concepts>
#include <cstddef>
 
#include "ecstasy/thread/LockableView.hpp"
 
namespace util
{
    class BitSet;
}
 
namespace ecstasy::query
{
    // clang-format off
 
    template <typename Q>
    concept QueryableObject = requires(Q &queryable, Q const &cqueryable, std::size_t index) {
        typename Q::QueryData;
 
        { cqueryable.getMask() } -> std::same_as<util::BitSet const &>;
 
        { queryable.getQueryData(index) } -> std::same_as<typename Q::QueryData>;
    };
 
    template <typename Q>
    concept ConstQueryableObject = QueryableObject<Q> && requires(const Q &cqueryable, std::size_t index) {
        typename Q::ConstQueryData;
 
        { cqueryable.getQueryData(index) } -> std::same_as<typename Q::ConstQueryData>;
    };
 
    template <typename W>
    concept QueryableWrapper = requires(W const &cwrapper) {
        typename W::WrappedType;
        
        { cwrapper->getMask() } -> std::same_as<util::BitSet const &>;
    } 
    && 
    (
        (
            QueryableObject<typename W::WrappedType> && 
            requires(W const &cwrapper, std::size_t index) {
                { cwrapper->getQueryData(index) } -> std::same_as<typename W::WrappedType::QueryData>;
            }
        )
        ||
        (
            std::is_const_v<typename W::WrappedType> &&
            ConstQueryableObject<std::remove_const_t<typename W::WrappedType>> && 
            requires(W const &cwrapper, std::size_t index) {
                { cwrapper->getQueryData(index) } -> std::same_as<typename W::WrappedType::ConstQueryData>;
            }
        )
    );
    // clang-format on
 
    template <typename Q>
    concept Queryable = QueryableObject<Q>
        || (std::is_const_v<Q> && ConstQueryableObject<std::remove_const_t<Q>>) || QueryableWrapper<Q>;
 
    template <Queryable Q>
    struct queryable_data {
        using type = typename Q::QueryData;
    };
 
    template <ConstQueryableObject Q>
    struct queryable_data<const Q> {
        using type = typename Q::ConstQueryData;
    };
 
    template <QueryableWrapper W>
    struct queryable_data<W> {
        using type = typename queryable_data<typename W::WrappedType>::type;
    };
 
    template <typename Q>
    using queryable_data_t = typename queryable_data<Q>::type;
 
    template <Queryable Q, bool ThreadSafe>
    struct thread_safe_queryable {
        using type = Q;
    };
 
    template <thread::Lockable Q>
    struct thread_safe_queryable<Q, true> {
        using type = thread::LockableView<Q>;
    };
 
    template <typename Q, bool ThreadSafe = true>
    using thread_safe_queryable_t = typename thread_safe_queryable<Q, ThreadSafe>::type;
 
    template <typename T, bool ThreadSafe>
    struct thread_safe_reference {
        using type = std::reference_wrapper<T>;
    };
 
    template <thread::Lockable T>
    struct thread_safe_reference<T, true> {
        using type = thread::LockableView<T>;
    };
 
    template <typename T, bool ThreadSafe = true>
    using thread_safe_reference_t = typename thread_safe_reference<T, ThreadSafe>::type;
 
    template <Queryable Q, bool AutoLock = false>
    struct queryable_qualifiers {
        using type = Q &;
    };
 
    template <thread::Lockable Q>
    struct queryable_qualifiers<Q, true> {
        using type = thread_safe_queryable_t<Q, true>;
    };
 
    template <typename Q, bool AutoLock = false>
    using queryable_qualifiers_t = typename queryable_qualifiers<Q, AutoLock>::type;
 
    // clang-format off
    // clang-format on
    template <Queryable Q>
    constexpr const util::BitSet &getQueryableMask(const Q &queryable)
    {
        if constexpr (QueryableWrapper<Q>)
            return queryable->getMask();
        else
            return queryable.getMask();
    }
 
    // clang-format off
    // clang-format on
    template <Queryable Q>
    constexpr queryable_data_t<Q> getQueryableData(Q &queryable, size_t index)
    {
        if constexpr (QueryableWrapper<Q>)
            return queryable->getQueryData(index);
        else
            return queryable.getQueryData(index);
    }
 
    template <typename T>
    struct is_queryable : public std::false_type {};
 
    template <Queryable T>
    struct is_queryable<T> : public std::true_type {};
 
    template <typename T>
    static constexpr inline bool is_queryable_v = is_queryable<T>::value;
 
    template <bool AutoLock, Queryable... Qs>
    struct views_allocator_size : public std::integral_constant<size_t, 0> {};
 
    template <bool AutoLock, Queryable Q, Queryable... Qs>
    struct views_allocator_size<AutoLock, Q, Qs...>
        : public
          // clang-format off
        std::integral_constant<size_t, views_allocator_size<AutoLock, Qs...>::value> {};
 
    template <thread::Lockable Q, Queryable... Qs>
    struct views_allocator_size<true, Q, Qs...>
        : public
          // clang-format off
        std::integral_constant<size_t, 
                sizeof(thread_safe_queryable_t<Q, true>) + 
                views_allocator_size<true, Qs...>::value> {};
    // clang-format on
 
    template <bool AutoLock, Queryable... Qs>
    size_t constexpr views_allocator_size_v = views_allocator_size<AutoLock, Qs...>::value;
 
} // namespace ecstasy::query
 
#endif /* !ECSTASY_QUERY_CONCEPTS_QUERYABLE_HPP_ */