pair.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace flecs {
 
namespace _ {
    struct pair_base { };
} // namespace _
 
 
template <typename First, typename Second>
struct pair : _::pair_base {
    using type = conditional_t<!is_empty<First>::value || is_empty<Second>::value, First, Second>; 
    using first = First; 
    using second = Second; 
    pair(type& v) : ref_(v) { }
 
    pair(const type& v) : ref_(const_cast<type&>(v)) { }
 
    operator type&() {
        return ref_;
    }
 
    operator const type&() const {
        return ref_;
    }
 
    type* operator->() {
        return &ref_;
    }
 
    const type* operator->() const {
        return &ref_;
    }
 
    type& operator*() {
        return ref_;
    }
 
    const type& operator*() const {
        return ref_;
    }
 
private:
    type& ref_;
};
 
template <typename First, typename Second, if_t<is_empty<First>::value> = 0>
using pair_object = pair<First, Second>;
 
template <typename T>
using raw_type_t = remove_pointer_t<remove_reference_t<T>>;
 
template <typename T>
struct is_pair {
    static constexpr bool value = is_base_of_v<_::pair_base, raw_type_t<T>>;
};
 
template <typename T>
inline constexpr bool is_pair_v = is_pair<T>::value;
 
template <typename P>
using pair_first_t = transcribe_cv_t<remove_reference_t<P>, typename raw_type_t<P>::first>;
 
template <typename P>
using pair_second_t = transcribe_cv_t<remove_reference_t<P>, typename raw_type_t<P>::second>;
 
template <typename P>
using pair_type_t = transcribe_cvp_t<remove_reference_t<P>, typename raw_type_t<P>::type>;
 
template <typename T, typename U = int>
struct actual_type;
 
template <typename T>
struct actual_type<T, if_not_t< is_pair<T>::value >> {
    using type = T;
};
 
template <typename T>
struct actual_type<T, if_t< is_pair<T>::value >> {
    using type = pair_type_t<T>;
};
 
template <typename T>
using actual_type_t = typename actual_type<T>::type;
 
 
template<typename T>
struct base_type {
    using type = decay_t< actual_type_t<T> >;
};
 
template <typename T>
using base_type_t = typename base_type<T>::type;
 
 
template<typename T>
struct base_arg_type {
    using type = remove_pointer_t< remove_reference_t< actual_type_t<T> > >;
};
 
template <typename T>
using base_arg_type_t = typename base_arg_type<T>::type;
 
 
template <typename T>
struct is_actual {
    static constexpr bool value = is_same_v<T, actual_type_t<T>>;
};
 
template <typename T>
inline constexpr bool is_actual_v = is_actual<T>::value;
 
namespace _ {
 
template <typename T>
struct is_sparse_field {
    static constexpr bool value = !is_pointer<T>::value &&
        !is_empty<actual_type_t<T>>::value && is_actual<T>::value &&
        dont_fragment<std::remove_cv_t<T>>::value;
};
 
template <typename T>
struct is_sparse_query_field {
    static constexpr bool value = is_sparse_field<T>::value &&
        on_instantiate_trait<std::remove_cv_t<T>>::value !=
            flecs::on_instantiate::inherit;
};
 
template <typename ... Components>
struct is_sparse_query {
    static constexpr bool value = sizeof...(Components) != 0 &&
        (is_sparse_query_field<remove_reference_t<Components>>::value && ...);
};
 
template <typename T>
struct is_sparse_component {
    static constexpr bool value =
        flecs::sparse<std::remove_cv_t<T>>::value ||
        dont_fragment<std::remove_cv_t<T>>::value;
};
 
template <typename T>
struct is_get_sparse_component {
    static constexpr bool value = is_sparse_component<T>::value &&
        on_instantiate_trait<std::remove_cv_t<T>>::value !=
            flecs::on_instantiate::inherit;
};
 
template <typename T>
const void* get_ptr(
    const flecs::world_t *world, flecs::entity_t entity, flecs::id_t id)
{
    if constexpr (is_get_sparse_component<T>::value) {
        return ecs_get_sparse_id(world, entity, id, sizeof(T));
    } else {
        return ecs_get_id(world, entity, id);
    }
}
 
template <typename T>
void* get_mut_ptr(
    const flecs::world_t *world, flecs::entity_t entity, flecs::id_t id)
{
    if constexpr (is_get_sparse_component<T>::value) {
        return ecs_get_sparse_id(world, entity, id, sizeof(T));
    } else {
        return ecs_get_mut_id(world, entity, id);
    }
}
 
} // namespace _
 
} // namespace flecs