VariableSet.hpp

#pragma once
#include <Core/RaCore.hpp>
 
#include <Core/Containers/DynamicVisitorBase.hpp>
#include <Core/Utils/Log.hpp>
#include <Core/Utils/StdExperimentalTypeTraits.hpp>
#include <Core/Utils/StdOptional.hpp>
#include <Core/Utils/TypesUtils.hpp>
 
#include <algorithm>
#include <any>
#include <functional>
#include <map>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace Ra {
namespace Core {
 
namespace detail {
template <typename type_t, class orig_t>
struct unwrap_impl {
    using type = orig_t;
};
 
template <typename type_t, class V>
struct unwrap_impl<std::reference_wrapper<type_t>, V> {
    using type = type_t;
};
} // namespace detail
 
template <class T>
struct unwrap {
    using type = typename detail::unwrap_impl<std::decay_t<T>, T>::type;
};
template <typename type_t>
using unwrap_t = typename unwrap<type_t>::type;
 
class DynamicVisitorBase;
class DynamicVisitor;
 
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 -> const T&;
    template <typename T>
    auto getVariable( const std::string& name ) -> T&;
 
    template <typename T>
    auto getVariableHandle( const std::string& name ) const -> const VariableHandle<T>;
 
    template <typename H>
    bool isHandleValid( const H& handle ) const;
 
    template <typename T>
    auto setVariable( 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...>;
    };
 
    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 VariableType>
    // same but more complex
    // std::reference_wrapper<std::decay_t<unwrap_t<typename
    //        VariableSet::VariableContainer<VariableType>::mapped_type>>>;
    using VisitTypeIndex = std::reference_wrapper<std::decay_t<unwrap_t<VariableType>>>;
 
    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();
 
    friend class DynamicVisitor;
};
 
// ------------------------------------------------------------------------------------------
// 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>& {
    assert( existsVariableType<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 ) -> T& {
    return const_cast<T&>( const_cast<const VariableSet*>( this )->getVariable<T>( name ) );
}
 
template <typename T>
auto VariableSet::getVariable( const std::string& name ) const -> const T& {
    return getVariableHandle<T>( name )->second;
}
 
template <typename T>
auto VariableSet::getVariableHandle( const std::string& name ) const -> 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::setVariable( 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( VisitTypeIndex<T> ) );
    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 ) {
            if ( auto cs = c.existsVariableType<T>(); cs ) return ( *cs )->size();
            return size_t { 0 }; // use 0uz when c++23
        } );
        // 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 coll = std::ref( c.getVariableStorage<T>() );
                    return { true, [coll]( DynamicVisitorBase& visitor, std::any&& userParam ) {
                                for ( auto&& t : coll.get() ) {
                                    visitor( t.first,
                                             std::any { std::ref( t.second ) },
                                             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;
}
 
/* --------------- Visitors */
 
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>() ) {
        for ( auto& element : *( variables.value() ) ) {
            visitor( element.first, element.second );
        }
    }
    if ( auto variables = existsVariableType<std::reference_wrapper<T>>(); variables ) {
        for ( auto& element : *( variables.value() ) ) {
            visitor( element.first, element.second.get() );
        }
    }
}
 
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 ) );
        }
    }
    if ( auto variables = existsVariableType<std::reference_wrapper<T>>(); variables ) {
        for ( auto& element : *( variables.value() ) ) {
            visitor( element.first, element.second.get(), std::forward<U>( userParams ) );
        }
    }
}
 
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