DynamicVisitor.hpp

#pragma once
#include <Core/RaCore.hpp>
 
#include <Core/Containers/DynamicVisitorBase.hpp>
#include <Core/Containers/VariableSet.hpp>
#include <Core/Utils/Log.hpp>
#include <Core/Utils/StdExperimentalTypeTraits.hpp>
#include <Core/Utils/StdOptional.hpp>
#include <Core/Utils/TypesUtils.hpp>
 
#include <any>
#include <functional>
#include <typeindex>
#include <unordered_map>
 
namespace Ra {
namespace Core {
 
class RA_CORE_API DynamicVisitor : public DynamicVisitorBase
{
  public:
    ~DynamicVisitor() override = default;
 
    void operator()( const std::string& name, std::any&& in, std::any&& userParam ) const override;
 
    [[nodiscard]] bool accept( const std::type_index& id ) const override;
 
    template <typename T, typename F>
    bool addOperator( F&& f );
 
    template <typename T>
    bool hasOperator();
 
    template <typename T, typename F>
    void addOrReplaceOperator( F&& f );
 
    template <typename T>
    bool removeOperator();
 
  private:
    using CallbackFunction = std::function<void( const std::string& name, std::any&, std::any&& )>;
 
    using OperatorsStorageType = std::unordered_map<std::type_index, CallbackFunction>;
 
    template <typename T, typename F>
    using WithParam =
        std::enable_if_t<std::is_invocable<F, const std::string&, T&, std::any&&>::value, bool>;
    template <typename T, typename F>
    using WithoutParam =
        std::enable_if_t<std::is_invocable<F, const std::string&, T&>::value, bool>;
 
    template <typename T, typename F, WithParam<T, F> = true>
    auto makeVisitorOperator( F& f ) -> OperatorsStorageType::value_type;
    template <typename T, typename F, WithoutParam<T, F> = true>
    auto makeVisitorOperator( F& f ) -> OperatorsStorageType::value_type;
 
    OperatorsStorageType m_visitorOperator;
};
class RA_CORE_API DynamicVisitor : public DynamicVisitorBase {…};
 
template <typename T, typename F>
bool DynamicVisitor::addOperator( F&& f ) {
    auto [it, inserted] = m_visitorOperator.insert( makeVisitorOperator<T, F>( f ) );
    return inserted;
}
bool DynamicVisitor::addOperator( F&& f ) {…}
 
template <typename T>
bool DynamicVisitor::hasOperator() {
    return m_visitorOperator.find( VariableSet::getVariableVisitTypeIndex<T>() ) !=
           m_visitorOperator.end();
}
bool DynamicVisitor::hasOperator() {…}
 
template <typename T, typename F>
void DynamicVisitor::addOrReplaceOperator( F&& f ) {
    auto op = makeVisitorOperator<T, F>( f );
    m_visitorOperator.insert_or_assign( op.first, op.second );
}
void DynamicVisitor::addOrReplaceOperator( F&& f ) {…}
 
template <typename T>
bool DynamicVisitor::removeOperator() {
    assert( hasOperator<T>() );
    auto res = m_visitorOperator.erase( VariableSet::getVariableVisitTypeIndex<T>() ) > 0;
    return res;
}
bool DynamicVisitor::removeOperator() {…}
 
template <typename T, typename F, DynamicVisitor::WithParam<T, F>>
auto DynamicVisitor::makeVisitorOperator( F& f ) -> OperatorsStorageType::value_type {
    return { // type index
             VariableSet::getVariableVisitTypeIndex<T>(),
             // callback
             [&f]( const std::string& name, std::any& a, std::any&& userParam ) {
                 auto rp = std::any_cast<std::reference_wrapper<T>>( a );
                 auto& p = rp.get();
                 f( name, p, std::forward<std::any>( userParam ) );
             } };
}
template <typename T, typename F, DynamicVisitor::WithoutParam<T, F>>
auto DynamicVisitor::makeVisitorOperator( F& f ) -> OperatorsStorageType::value_type {
    return { // type index
             VariableSet::getVariableVisitTypeIndex<T>(),
             // callback
             [&f]( const std::string& name, std::any& a, std::any&& ) {
                 auto rp = std::any_cast<std::reference_wrapper<T>>( a );
                 auto& p = rp.get();
                 f( name, p );
             } };
}
} // namespace Core
} // namespace Ra