components.inl

Go to the documentation of this file.

/**
 
    @file      components.inl
    @author    Khrapov
    @date      7.03.2021
    @copyright © Nick Khrapov, 2021. All right reserved.
 
**/
 
namespace qx
{
 
namespace details
{
 
template<class base_component_t, std::derived_from<base_component_t> component_t>
struct get_inheritance_sequence
{
    /*
        |    | rtti_base | c1 | base_component_t | c2 | c3 | component_t |
        | t1 | <=======================================================> |
        | t2 | <===============================>                         |
        | t3 |                                    <====================> |
    */
    using t1 = typename component_t::inheritance_tuple_type;
    using t2 = typename base_component_t::inheritance_tuple_type;
    using t3 = tuple_utils::remove_t<t1, t2>;
 
    using type = t3;
};
 
} // namespace details
 
inline component_status_key::component_status_key(priority ePriority, flags<component_status> eStatusFlags) noexcept
    : time_ordered_priority_key(ePriority)
    , m_eStatusFlags(eStatusFlags)
{
}
 
constexpr flags<component_status> component_status_key::get_status_flags() const noexcept
{
    return m_eStatusFlags;
}
 
constexpr void component_status_key::set_status_flags(flags<component_status> eStatusFlags) noexcept
{
    m_eStatusFlags = eStatusFlags;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
typename components<base_component_t>::class_data& components<base_component_t>::class_data::get_or_add_class_data(
    class_id id) noexcept
{
    if (const auto it = derivedClasses.find(id); it != derivedClasses.end())
        return *it->second.get();
 
    auto pClassData    = std::make_unique<class_data>();
    auto pRawClassData = pClassData.get();
    derivedClasses[id] = std::move(pClassData);
    return *pRawClassData;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
component_t* components<base_component_t>::add(
    std::unique_ptr<component_t> pComponent,
    priority                     ePriority,
    flags<component_status>      statusFlags) noexcept
{
    if (!pComponent)
        return nullptr;
 
    auto        pRawComponent = pComponent.get();
    class_data& classData     = iterate_class_data(
        pRawComponent,
        [ePriority, statusFlags, pRawComponent](class_data& classData)
        {
            classData.priorityCache.emplace(component_status_key(ePriority, statusFlags), pRawComponent);
        });
    classData.components.push_back(std::move(pComponent));
    return pRawComponent;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
std::unique_ptr<base_component_t> components<base_component_t>::remove(const base_component_t* pRawComponent) noexcept
{
    if (!pRawComponent)
        return nullptr;
 
    class_data& classData = iterate_class_data(
        pRawComponent,
        [pRawComponent](class_data& classData)
        {
            std::erase_if(
                classData.priorityCache,
                [pRawComponent](const auto& pair)
                {
                    return pair.second == pRawComponent;
                });
        });
 
    const auto it = std::ranges::find_if(
        classData.components,
        [pRawComponent](const pointer_type& pointer)
        {
            return pointer.get() == pRawComponent;
        });
 
    if (it == classData.components.end())
        return nullptr;
 
    std::unique_ptr<base_component_t> pComponent = std::move(*it);
    classData.components.erase(it);
    return pComponent;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
component_t* components<base_component_t>::try_get(bool bIncludeDisabled) noexcept
{
    class_data& classData = get_or_add_class_data<component_t>();
    const auto  it        = std::ranges::find_if(
        classData.priorityCache,
        [bIncludeDisabled](const auto& pair)
        {
            return bIncludeDisabled || !pair.first.get_status_flags().contains(component_status::disabled);
        });
 
    return it != classData.priorityCache.end() ? static_cast<component_t*>(it->second) : nullptr;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
const component_t* components<base_component_t>::try_get(bool bIncludeDisabled) const noexcept
{
    return QX_CONST_CAST_THIS()->template try_get<component_t>(bIncludeDisabled);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
component_t* components<base_component_t>::try_get(class_id id, bool bIncludeDisabled) noexcept
{
    // we could improve it from O(N) to O(log(N)) if we could use id->is_derived_from(id) without an object itself
    // we will do it when a reflection system is fully implemented
    const auto it = std::ranges::find_if(
        m_RootClass.priorityCache,
        [id, bIncludeDisabled](const auto& pair)
        {
            return (bIncludeDisabled || !pair.first.get_status_flags().contains(component_status::disabled))
                   && pair.second->is_derived_from_id(id);
        });
 
    return it != m_RootClass.priorityCache.end() ? rtti_cast<component_t>(it->second) : nullptr;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
const component_t* components<base_component_t>::try_get(class_id id, bool bIncludeDisabled) const noexcept
{
    return QX_CONST_CAST_THIS()->template try_get<component_t>(id, bIncludeDisabled);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
component_t& components<base_component_t>::get(bool bIncludeDisabled) noexcept
{
    return *try_get<component_t>(bIncludeDisabled);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
const component_t& components<base_component_t>::get(bool bIncludeDisabled) const noexcept
{
    return QX_CONST_CAST_THIS()->template get<component_t>(bIncludeDisabled);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
base_component_t& components<base_component_t>::get(class_id id, bool bIncludeDisabled) noexcept
{
    return *try_get<component_t>(id, bIncludeDisabled);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
const base_component_t& components<base_component_t>::get(class_id id, bool bIncludeDisabled) const noexcept
{
    return QX_CONST_CAST_THIS()->template get<component_t>(id, bIncludeDisabled);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
auto components<base_component_t>::view() noexcept
{
    class_data& classData = get_or_add_class_data<component_t>();
    return classData.priorityCache
           | std::views::filter(
               [](const auto& pair)
               {
                   return pair.second->template is_derived_from<component_t>()
                          && !pair.first.get_status_flags().contains(component_status::disabled);
               })
           | std::views::transform(
               [](auto& pair) -> component_t&
               {
                   return *static_cast<component_t*>(pair.second);
               });
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
auto components<base_component_t>::view() const noexcept
{
    const class_data& classData = get_or_add_class_data<component_t>();
    return classData.priorityCache
           | std::views::filter(
               [](const auto& pair)
               {
                   return pair.second->template is_derived_from<component_t>()
                          && !pair.first.get_status_flags().contains(component_status::disabled);
               })
           | std::views::transform(
               [](const auto& pair) -> const component_t&
               {
                   return *static_cast<const component_t*>(pair.second);
               });
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
std::optional<flags<component_status>> components<base_component_t>::get_component_status(
    const base_component_t* pRawComponent) const noexcept
{
    std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
    return optComponentStatus ? std::optional(optComponentStatus->get_status_flags()) : std::nullopt;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
bool components<base_component_t>::set_component_status(
    const base_component_t* pRawComponent,
    flags<component_status> newStatus) noexcept
{
    std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
    if (!optComponentStatus)
        return false;
 
    optComponentStatus->set_status_flags(newStatus);
    return set_status(pRawComponent, *optComponentStatus);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
bool components<base_component_t>::add_component_status(
    const base_component_t* pRawComponent,
    flags<component_status> newStatuses) noexcept
{
    std::optional<flags<component_status>> optComponentStatus = get_component_status(pRawComponent);
    if (!optComponentStatus)
        return false;
 
    optComponentStatus->add(newStatuses);
    return set_component_status(pRawComponent, *optComponentStatus);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
bool components<base_component_t>::remove_component_status(
    const base_component_t* pRawComponent,
    flags<component_status> statusesToRemove) noexcept
{
    std::optional<flags<component_status>> optComponentStatus = get_component_status(pRawComponent);
    if (!optComponentStatus)
        return false;
 
    optComponentStatus->remove(statusesToRemove);
    return set_component_status(pRawComponent, *optComponentStatus);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
std::optional<priority> components<base_component_t>::get_component_priority(
    const base_component_t* pRawComponent) const noexcept
{
    std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
    return optComponentStatus ? std::optional(optComponentStatus->get_priority()) : std::nullopt;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
bool components<base_component_t>::set_component_priority(
    const base_component_t* pRawComponent,
    priority                eNewComponentPriority) noexcept
{
    std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
    if (!optComponentStatus)
        return false;
 
    optComponentStatus->set_priority(eNewComponentPriority);
    return set_status(pRawComponent, *optComponentStatus);
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
bool components<base_component_t>::empty() const noexcept
{
    return m_RootClass.priorityCache.empty();
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
void components<base_component_t>::clear() noexcept
{
    m_RootClass.derivedClasses.clear();
    m_RootClass.components.clear();
    m_RootClass.priorityCache.clear();
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
std::optional<component_status_key> components<base_component_t>::get_status(
    const base_component_t* pRawComponent) const noexcept
{
    if (!pRawComponent)
        return std::nullopt;
 
    auto it = std::ranges::find_if(
        m_RootClass.priorityCache,
        [pRawComponent](const auto& pair)
        {
            return pair.second == pRawComponent;
        });
 
    return it != m_RootClass.priorityCache.end() ? std::optional<component_status_key>(it->first) : std::nullopt;
}
 
 
template<std::derived_from<rtti_pure_base> base_component_t>
bool components<base_component_t>::set_status(
    const base_component_t* pRawComponent,
    component_status_key    status) noexcept
{
    if (!pRawComponent)
        return false;
 
    bool bChanged = true;
    iterate_class_data(
        pRawComponent,
        [pRawComponent, status, &bChanged](class_data& classData)
        {
            const auto it = std::ranges::find_if(
                classData.priorityCache,
                [pRawComponent](const auto& pair)
                {
                    return pair.second == pRawComponent;
                });
 
            if (it == classData.priorityCache.end())
            {
                bChanged = false;
                return;
            }
 
            if (it->first != status)
            {
                classData.priorityCache.emplace(status, it->second);
                classData.priorityCache.erase(it);
            }
        });
 
    return bChanged;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<
    std::derived_from<base_component_t>                                  component_t,
    callable_c<void, typename components<base_component_t>::class_data&> callable_t>
typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
    callable_t iterateClassDataFunction) noexcept
{
    class_data* pClassData = &m_RootClass;
    iterateClassDataFunction(*pClassData);
 
    tuple_utils::iterate<typename details::get_inheritance_sequence<base_component_t, component_t>::type>(
        [&pClassData, &iterateClassDataFunction]<class T, size_t I>()
        {
            pClassData = &pClassData->get_or_add_class_data(T::get_class_id_static());
            iterateClassDataFunction(*pClassData);
        });
 
    return *pClassData;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<
    std::derived_from<base_component_t>                                  component_t,
    callable_c<void, typename components<base_component_t>::class_data&> callable_t>
const typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
    callable_t iterateClassDataFunction) const noexcept
{
    return QX_CONST_CAST_THIS()->template iterate_class_data<component_t>(std::move(iterateClassDataFunction));
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data() noexcept
{
    class_data* pClassData = &m_RootClass;
 
    tuple_utils::iterate<typename details::get_inheritance_sequence<base_component_t, component_t>::type>(
        [&pClassData]<class T, size_t I>()
        {
            pClassData = &pClassData->get_or_add_class_data(T::get_class_id_static());
        });
 
    return *pClassData;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<std::derived_from<base_component_t> component_t>
const typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data()
    const noexcept
{
    return QX_CONST_CAST_THIS()->template get_or_add_class_data<component_t>();
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<callable_c<void, typename components<base_component_t>::class_data&> callable_t>
typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
    const base_component_t* pRawComponent,
    callable_t              iterateClassDataFunction) noexcept
{
    class_data* pClassData = &m_RootClass;
    iterateClassDataFunction(*pClassData);
 
    std::span<const class_id> allIds = pRawComponent->get_inheritance_sequence();
    std::span<const class_id> baseClassIds(
        std::ranges::find(allIds, base_component_t::get_class_id_static()),
        allIds.end());
 
    for (auto it = baseClassIds.begin() + 1; it != baseClassIds.end(); ++it)
    {
        pClassData = &pClassData->get_or_add_class_data(*it);
        iterateClassDataFunction(*pClassData);
    }
 
    return *pClassData;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
template<callable_c<void, typename components<base_component_t>::class_data&> callable_t>
const typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
    const base_component_t* pRawComponent,
    callable_t              iterateClassDataFunction) const noexcept
{
    return QX_CONST_CAST_THIS()->iterate_class_data(pRawComponent, std::move(iterateClassDataFunction));
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data(
    const base_component_t* pRawComponent) noexcept
{
    class_data* pClassData = &m_RootClass;
 
    std::span<const class_id> allIds = pRawComponent->get_inheritance_sequence();
    std::span<const class_id> baseClassIds(
        std::ranges::find(allIds, base_component_t::get_class_id_static()),
        allIds.end());
 
    for (auto it = baseClassIds.begin() + 1; it != baseClassIds.end(); ++it)
        pClassData = &pClassData->get_or_add_class_data(*it);
 
    return *pClassData;
}
 
template<std::derived_from<rtti_pure_base> base_component_t>
const typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data(
    const base_component_t* pRawComponent) const noexcept
{
    return QX_CONST_CAST_THIS()->get_or_add_class_data(pRawComponent);
}
 
} // namespace qx