VariableSet.hpp

#pragma once
#include <Core/RaCore.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 <map>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace Ra {
namespace Core {
 
class RA_CORE_API VariableSet
{
  public:
    template <typename T>
    using VariableContainer = std::map<std::string, T>;
 
    template <typename T>
    using Variable = typename VariableContainer<T>::value_type;
 
    template <typename T>
    using VariableType = typename Variable<T>::second_type;
 
    template <typename T>
    using VariableHandle = typename VariableContainer<T>::iterator;
 
    template <typename H>
    using VariableTypeFromHandle = typename std::iterator_traits<H>::value_type::second_type;
 
    // ----------------------------------------------------------
    VariableSet() : m_vtable( VariableSetFunctions::getInstance() ) {}
    ~VariableSet() = default;
    VariableSet( const VariableSet& other ) noexcept :
        m_vtable( VariableSetFunctions::getInstance() ) {
        *this = other;
    }
    VariableSet( VariableSet&& other ) noexcept : m_vtable( VariableSetFunctions::getInstance() ) {
        *this = std::move( other );
    }
 
    // ------------------------------------------------------------------------------------------
    // Global variable set operation
    // ------------------------------------------------------------------------------------------
    auto operator=( const VariableSet& other ) -> VariableSet&;
 
    auto operator=( VariableSet&& other ) noexcept -> VariableSet&;
 
    void clear();
 
    void mergeKeepVariables( const VariableSet& from );
 
    void mergeReplaceVariables( const VariableSet& from );
 
    size_t size() const;
 
    auto getStoredTypes() const -> const std::vector<std::type_index>& { return m_storedType; }
 
    // ------------------------------------------------------------------------------------------
    // Per variable operations
    // ------------------------------------------------------------------------------------------
    template <typename T>
    auto insertVariable( const std::string& name, const T& value )
        -> std::pair<VariableHandle<T>, bool>;
 
    template <typename T>
    auto getVariable( const std::string& name ) const -> T&;
 
    template <typename T>
    auto getVariableHandle( const std::string& name ) const -> VariableHandle<T>;
 
    template <typename H>
    bool isHandleValid( const H& handle ) const;
 
    template <typename T>
    auto insertOrAssignVariable( const std::string& name, const T& value )
        -> std::pair<VariableHandle<T>, bool>;
 
    template <typename T>
    bool deleteVariable( const std::string& name );
 
    template <typename H>
    bool deleteVariable( H& handle );
 
    template <typename T>
    auto existsVariable( const std::string& name ) const -> Utils::optional<VariableHandle<T>>;
 
 
    // ------------------------------------------------------------------------------------------
    // Per type access
    // ------------------------------------------------------------------------------------------
    template <typename T>
    auto existsVariableType() const -> Utils::optional<VariableContainer<T>*>;
 
    template <typename T>
    bool deleteAllVariables();
 
    template <typename T>
    auto getAllVariables() const -> VariableContainer<T>&;
 
    template <typename H>
    auto getAllVariablesFromHandle( const H& handle )
        -> VariableContainer<VariableTypeFromHandle<H>>&;
 
    template <typename T>
    size_t numberOf() const;
 
 
    template <typename... TYPES>
    struct StaticVisitor {
        using types = Utils::TypeList<TYPES...>;
    };
 
    class DynamicVisitorBase
    {
      public:
        virtual ~DynamicVisitorBase() = default;
 
        virtual void operator()( std::any&& in, std::any&& userParam ) const = 0;
 
        [[nodiscard]] virtual bool accept( const std::type_index& id ) const = 0;
    };
 
    class RA_CORE_API DynamicVisitor : public DynamicVisitorBase
    {
      public:
        ~DynamicVisitor() override = default;
 
        void operator()( 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( std::any&, std::any&& )>;
 
        using OperatorsStorageType = std::unordered_map<std::type_index, CallbackFunction>;
 
        template <typename T, typename F, bool WithUserParam>
        struct MakeVisitOperatorHelper {
            auto makeOperator( F& f ) -> OperatorsStorageType::value_type;
        };
 
        template <typename T, typename F>
        auto makeVisitorOperator( F& f ) -> OperatorsStorageType::value_type;
 
        OperatorsStorageType m_visitorOperator;
    };
 
    template <typename F>
    void visit( F&& visitor ) const;
 
    template <typename F, typename T>
    void visit( F&& visitor, T& userParams ) const;
 
    template <typename F, typename T>
    void visit( F&& visitor, T&& userParams ) const;
 
  private:
    template <typename P = bool>
    void visitDynamic( DynamicVisitorBase& visitor, P&& params = P {} ) const;
 
    template <typename F>
    void visitStatic( F&& visitor ) const;
 
    template <typename F, typename T>
    void visitStatic( F&& visitor, T& userParams ) const;
 
    template <typename F, typename T>
    void visitStatic( F&& visitor, T&& userParams ) const;
 
    template <typename T>
    static auto getVariableVisitTypeIndex() -> std::type_index;
 
    template <typename T>
    auto addVariableType() -> Utils::optional<VariableContainer<T>*>;
 
    template <typename F, typename T>
    using VisitFunction =
        decltype( std::declval<F>().operator()( std::declval<const std::string&>(),
                                                std::declval<T&>() ) );
 
    template <typename F, typename T, typename U>
    using VisitFunctionWithUserParam =
        decltype( std::declval<F>().operator()( std::declval<const std::string&>(),
                                                std::declval<T&>(),
                                                std::declval<U&&>() ) );
 
    template <typename F, typename T>
    static constexpr bool has_visit_callable_v =
        Ra::Core::Utils::is_detected<VisitFunction, F, T>::value;
 
    template <typename F, typename T, typename U>
    static constexpr bool has_visit_callable_with_user_param_v =
        Ra::Core::Utils::is_detected<VisitFunctionWithUserParam, F, T, U>::value;
 
    template <typename F, template <typename...> typename TYPESLIST, typename... TYPES>
    void visitImpl( F&& visitor, TYPESLIST<TYPES...> ) const;
 
    template <typename F, typename T>
    void visitImplHelper( F& visitor ) const;
 
    template <typename F, typename U, template <typename...> typename TYPESLIST, typename... TYPES>
    void visitImplUserParam( F&& visitor, U&& userParam, TYPESLIST<TYPES...> ) const;
 
    template <typename F, typename U, typename T>
    void visitImplHelperUserParam( F& visitor, U&& userParams ) const;
 
 
 
    class VariableSetFunctions
    {
      public:
        using ClearFunctionType = std::function<void( VariableSet& )>;
        using MergeFunctionType = std::function<void( const VariableSet&, VariableSet& )>;
        using SizeFunctionType  = std::function<size_t( const VariableSet& )>;
        // Should be these simplified ????
        using VisitFunctorType =
            std::function<std::pair<bool, std::function<void( DynamicVisitorBase&, std::any&& )>>(
                const VariableSet&,
                const DynamicVisitorBase& )>;
 
        VariableSetFunctions( const VariableSetFunctions& ) = delete;
        void operator=( const VariableSetFunctions& )       = delete;
 
      protected:
        VariableSetFunctions()  = default;
        ~VariableSetFunctions() = default;
 
      public:
        // static variable ref singleton implementation.
        static auto getInstance() -> VariableSetFunctions*;
 
        std::vector<MergeFunctionType> m_mergeKeepFunctions;
        std::vector<MergeFunctionType> m_mergeReplaceFunctions;
        std::vector<SizeFunctionType> m_sizeFunctions;
        std::vector<VisitFunctorType> m_visitFunctions;
        std::vector<std::type_index> m_storedType;
    };
 
    VariableSetFunctions* m_vtable;
 
 
    // Storage of the variable in a type-erased associative container
    mutable std::unordered_map<std::type_index, std::any> m_variables;
    std::unordered_map<std::type_index, size_t> m_typeIndexToVtableIndex;
    std::vector<std::type_index> m_storedType;
 
    template <typename T>
    auto createVariableStorage() -> VariableContainer<T>*;
 
    template <typename T>
    auto getVariableStorage() const -> VariableContainer<T>&;
 
    template <typename T>
    void removeVariableStorage();
 
};
 
// ------------------------------------------------------------------------------------------
// Storage management
// ------------------------------------------------------------------------------------------
 
template <typename T>
auto VariableSet::createVariableStorage() -> VariableContainer<T>* {
    m_variables[std::type_index { typeid( T ) }].emplace<VariableContainer<T>>();
    return std::any_cast<VariableContainer<T>>( &( m_variables[std::type_index { typeid( T ) }] ) );
}
 
template <typename T>
auto VariableSet::getVariableStorage() const -> VariableContainer<T>& {
    return std::any_cast<VariableContainer<T>&>( m_variables[std::type_index { typeid( T ) }] );
}
 
template <typename T>
void VariableSet::removeVariableStorage() {
    auto type = std::type_index { typeid( T ) };
    m_variables.erase( type );
    m_typeIndexToVtableIndex.erase( type );
 
    auto newEnd = std::remove( m_storedType.begin(), m_storedType.end(), type );
    m_storedType.erase( newEnd, m_storedType.end() );
}
 
// ------------------------------------------------------------------------------------------
// Templated methods definition
// ------------------------------------------------------------------------------------------
template <typename T>
auto VariableSet::insertVariable( const std::string& name, const T& value )
    -> std::pair<VariableHandle<T>, bool> {
    auto typeAccess = existsVariableType<T>();
    // If it is the first parameter of the given type, first register the type
    if ( !typeAccess ) { typeAccess = addVariableType<T>(); }
    // insert the parameter.
    return ( *typeAccess )->insert( { name, value } );
}
 
template <typename T>
auto VariableSet::getVariable( const std::string& name ) const -> T& {
    assert( existsVariable<T>( name ) );
    return getVariableHandle<T>( name )->second;
}
 
template <typename T>
auto VariableSet::getVariableHandle( const std::string& name ) const -> VariableHandle<T> {
    assert( existsVariableType<T>() );
    return getVariableStorage<T>().find( name );
}
 
template <typename H>
bool VariableSet::isHandleValid( const H& handle ) const {
    if ( !existsVariableType<VariableTypeFromHandle<H>>() ) { return false; }
    return handle != getVariableStorage<VariableTypeFromHandle<H>>().end();
}
 
template <typename T>
auto VariableSet::insertOrAssignVariable( const std::string& name, const T& value )
    -> std::pair<VariableHandle<T>, bool> {
    auto typeAccess = existsVariableType<T>();
    // If it is the first parameter of the given type, first register the type
    if ( !typeAccess ) { typeAccess = addVariableType<T>(); }
    // insert the parameter.
    return ( *typeAccess )->insert_or_assign( name, value );
}
 
template <typename T>
bool VariableSet::deleteVariable( const std::string& name ) {
    if ( auto typeAccess = existsVariableType<T>(); typeAccess ) {
        auto removed = ( *typeAccess )->erase( name );
        // remove the type related function when the container has no more data of this type
        if ( numberOf<T>() == 0 ) { deleteAllVariables<T>(); }
        return removed > 0;
    }
    return false;
}
 
template <typename H>
bool VariableSet::deleteVariable( H& handle ) {
    assert( isHandleValid( handle ) );
    auto varname = handle->first;
    handle       = getVariableStorage<VariableTypeFromHandle<H>>().end();
    return deleteVariable<VariableTypeFromHandle<H>>( varname );
}
 
template <typename T>
auto VariableSet::existsVariable( const std::string& name ) const
    -> Utils::optional<VariableHandle<T>> {
    if ( auto typeAccess = existsVariableType<T>(); typeAccess ) {
        auto itr = ( *typeAccess )->find( name );
        if ( itr != ( *typeAccess )->cend() ) { return itr; }
    }
    return {};
}
 
template <typename T>
auto VariableSet::getVariableVisitTypeIndex() -> std::type_index {
    static std::type_index idT(
        typeid( std::reference_wrapper<typename VariableSet::VariableContainer<T>::value_type> ) );
    return idT;
}
 
template <typename T>
auto VariableSet::addVariableType() -> Utils::optional<VariableContainer<T>*> {
    auto storage = createVariableStorage<T>();
 
    auto tidx = std::type_index( typeid( T ) );
    auto it   = std::find( m_vtable->m_storedType.begin(), m_vtable->m_storedType.end(), tidx );
 
    // remember the stored type and its rank for the instance
    m_typeIndexToVtableIndex[tidx] = it - m_vtable->m_storedType.begin();
    m_storedType.push_back( tidx );
 
    // If the type is not already there, add type operations and identifier in the global vtable
    if ( it == m_vtable->m_storedType.end() ) {
        // remember the stored type in the global vtable
        m_vtable->m_storedType.emplace_back( tidx );
        // used to merge (keep) the stored data from container "from" to container "to"
        m_vtable->m_mergeKeepFunctions.emplace_back(
            []( const VariableSet& from, VariableSet& to ) {
                auto toStorageAccess = to.existsVariableType<T>();
                if ( !toStorageAccess ) { toStorageAccess = to.addVariableType<T>(); }
                auto& toStorage   = *( toStorageAccess.value() );
                auto& fromStorage = from.getVariableStorage<T>();
                for ( const auto& t : fromStorage ) {
                    toStorage.insert( t );
                }
            } );
        // used to merge (replace) the stored data from container "from" to container "to"
        m_vtable->m_mergeReplaceFunctions.emplace_back(
            []( const VariableSet& from, VariableSet& to ) {
                auto toStorageAccess = to.existsVariableType<T>();
                if ( !toStorageAccess ) { toStorageAccess = to.addVariableType<T>(); }
                auto& toStorage   = *( toStorageAccess.value() );
                auto& fromStorage = from.getVariableStorage<T>();
                for ( const auto& t : fromStorage ) {
                    toStorage.insert_or_assign( t.first, t.second );
                }
            } );
        // use to compute gauge on the stored data
        m_vtable->m_sizeFunctions.emplace_back(
            []( const VariableSet& c ) { return c.getVariableStorage<T>().size(); } );
        // used to visit the variableSet with a dynamic visitor
        m_vtable->m_visitFunctions.emplace_back(
            []( const VariableSet& c, const DynamicVisitorBase& v )
                -> std::pair<bool, std::function<void( DynamicVisitorBase&, std::any && )>> {
                auto id = getVariableVisitTypeIndex<T>();
                if ( v.accept( id ) ) {
                    auto& storage = c.getVariableStorage<T>();
                    auto coll     = std::ref( storage );
                    return { true, [coll]( DynamicVisitorBase& visitor, std::any&& userParam ) {
                                for ( auto&& t : coll.get() ) {
                                    visitor( { std::ref( t ) },
                                             std::forward<std::any>( userParam ) );
                                }
                            } };
                }
                else { return { false, nullptr }; }
            } );
    }
    return storage;
}
 
template <typename T>
auto VariableSet::existsVariableType() const -> Utils::optional<VariableContainer<T>*> {
    auto iter = m_variables.find( std::type_index { typeid( T ) } );
    if ( iter == m_variables.cend() ) { return {}; }
    else { return std::any_cast<VariableSet::VariableContainer<T>>( &( iter->second ) ); }
}
 
template <typename T>
bool VariableSet::deleteAllVariables() {
    if ( existsVariableType<T>() ) {
        removeVariableStorage<T>();
        return true;
    }
    return false;
}
 
template <typename T>
auto VariableSet::getAllVariables() const -> VariableContainer<T>& {
    // just assert on the existence of the type to prevent undefined behavior when dereferencing
    // the optional
    assert( existsVariableType<T>() );
    // trows std::bad_any_cast if type does not exist
    return getVariableStorage<T>();
}
 
template <typename H>
auto VariableSet::getAllVariablesFromHandle( const H& )
    -> VariableContainer<VariableTypeFromHandle<H>>& {
    assert( existsVariableType<VariableTypeFromHandle<H>>() );
    return getVariableStorage<VariableTypeFromHandle<H>>();
}
 
template <typename T>
size_t VariableSet::numberOf() const {
    if ( auto variables = existsVariableType<T>(); variables ) { return ( *variables )->size(); }
    return 0;
}
 
template <typename P>
void VariableSet::visitDynamic( DynamicVisitorBase& visitor, P&& params ) const {
    for ( const auto& [type, index] : m_typeIndexToVtableIndex ) {
        auto [accepted, loop] = m_vtable->m_visitFunctions[index]( *this, visitor );
        if ( accepted ) { loop( visitor, std::forward<P>( params ) ); }
    }
}
 
template <typename F>
void VariableSet::visitStatic( F&& visitor ) const {
    visitImpl( visitor, typename std::decay_t<F>::types {} );
}
 
template <typename F, template <typename...> typename TYPESLIST, typename... TYPES>
void VariableSet::visitImpl( F&& visitor, TYPESLIST<TYPES...> ) const {
    ( ..., visitImplHelper<std::decay_t<F>, TYPES>( visitor ) );
}
 
template <typename F, typename T>
void VariableSet::visitImplHelper( F& visitor ) const {
    static_assert( has_visit_callable_v<F, T>,
                   "Static visitors must provide a function with profile "
                   "void( const std::string& name, [const ]T[&] value) for each "
                   "declared visitable type T" );
    if ( auto variables = existsVariableType<T>(); variables ) {
        for ( auto& element : *( variables.value() ) ) {
            visitor( element.first, element.second );
        }
    }
}
 
template <typename F, typename U>
void VariableSet::visitStatic( F&& visitor, U& userParams ) const {
    visitImplUserParam(
        visitor, std::forward<U>( userParams ), typename std::decay_t<F>::types {} );
}
 
template <typename F, typename U>
void VariableSet::visitStatic( F&& visitor, U&& userParams ) const {
    visitImplUserParam(
        visitor, std::forward<U>( userParams ), typename std::decay_t<F>::types {} );
}
 
template <typename F, typename U, template <typename...> typename TYPESLIST, typename... TYPES>
void VariableSet::visitImplUserParam( F&& visitor, U&& userParam, TYPESLIST<TYPES...> ) const {
    ( ...,
      visitImplHelperUserParam<std::decay_t<F>, U, TYPES>( visitor,
                                                           std::forward<U>( userParam ) ) );
}
 
template <typename F, typename U, typename T>
void VariableSet::visitImplHelperUserParam( F& visitor, U&& userParams ) const {
    static_assert( has_visit_callable_with_user_param_v<F, T, U>,
                   "Static visitors must provide a function with profile "
                   "void( const std::string& name, [const ]T[&] value, [const] U&&) for each "
                   "declared visitable type T" );
    if ( auto variables = existsVariableType<T>(); variables ) {
        for ( auto& element : *( variables.value() ) ) {
            visitor( element.first, element.second, std::forward<U>( userParams ) );
        }
    }
}
 
template <typename T, typename F>
bool VariableSet::DynamicVisitor::addOperator( F&& f ) {
    auto [it, inserted] = m_visitorOperator.insert( makeVisitorOperator<T, F>( f ) );
    return inserted;
}
 
template <typename T>
bool VariableSet::DynamicVisitor::hasOperator() {
    return m_visitorOperator.find( getVariableVisitTypeIndex<T>() ) != m_visitorOperator.end();
}
 
template <typename T, typename F>
void VariableSet::DynamicVisitor::addOrReplaceOperator( F&& f ) {
    auto op = makeVisitorOperator<T, F>( f );
    m_visitorOperator.insert_or_assign( op.first, op.second );
}
 
template <typename T>
bool VariableSet::DynamicVisitor::removeOperator() {
    assert( hasOperator<T>() );
    auto res = m_visitorOperator.erase( getVariableVisitTypeIndex<T>() ) > 0;
    return res;
}
 
template <typename T, typename F>
struct VariableSet::DynamicVisitor::MakeVisitOperatorHelper<T, F, true> {
    inline auto makeOperator( F& f ) -> OperatorsStorageType::value_type {
        return { getVariableVisitTypeIndex<T>(), [&f]( std::any& a, std::any&& userParam ) {
                    auto rp = std::any_cast<std::reference_wrapper<VariableSet::Variable<T>>&>( a );
                    auto& p = rp.get();
                    f( p.first, p.second, std::forward<std::any>( userParam ) );
                } };
    }
};
 
template <typename T, typename F>
struct VariableSet::DynamicVisitor::MakeVisitOperatorHelper<T, F, false> {
    inline auto makeOperator( F& f ) -> OperatorsStorageType::value_type {
        return { getVariableVisitTypeIndex<T>(), [&f]( std::any& a, std::any&& ) {
                    auto rp = std::any_cast<std::reference_wrapper<VariableSet::Variable<T>>&>( a );
                    auto& p = rp.get();
                    f( p.first, p.second );
                } };
    }
};
 
template <class T, class F>
inline auto VariableSet::DynamicVisitor::makeVisitorOperator( F& f )
    -> OperatorsStorageType::value_type {
    auto opBuilder = MakeVisitOperatorHelper < T, F,
         std::is_invocable<F, const std::string&, T, std::any&&>::value ||
             std::is_invocable<F, const std::string&, T&, std::any&&>::value > {};
    return opBuilder.makeOperator( f );
}
 
template <typename F>
inline void VariableSet::visit( F&& visitor ) const {
    if constexpr ( std::is_base_of<DynamicVisitorBase, std::decay_t<F>>::value ) {
        visitDynamic( visitor );
    }
    else { visitStatic( visitor ); }
}
 
template <typename F, typename T>
inline void VariableSet::visit( F&& visitor, T& userParams ) const {
    if constexpr ( std::is_base_of<DynamicVisitorBase, std::decay_t<F>>::value ) {
        visitDynamic( visitor, std::forward<T&>( userParams ) );
    }
    else { visitStatic( visitor, std::forward<T&>( userParams ) ); }
}
 
template <typename F, typename T>
inline void VariableSet::visit( F&& visitor, T&& userParams ) const {
    if constexpr ( std::is_base_of<DynamicVisitorBase, std::decay_t<F>>::value ) {
        visitDynamic( visitor, std::forward<T&&>( userParams ) );
    }
    else { visitStatic( visitor, std::forward<T&&>( userParams ) ); }
}
 
} // namespace Core
} // namespace Ra