VariableSetEnumManagement.hpp

#pragma once
 
#include <Core/Containers/VariableSet.hpp>
#include <Core/Utils/EnumConverter.hpp>
 
#include <string>
 
namespace Ra {
namespace Core {
namespace VariableSetEnumManagement {
 
template <typename EnumBaseType>
void addEnumConverter( VariableSet& vs,
                       const std::string& name,
                       std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>> converter );
 
template <typename EnumBaseType>
Core::Utils::optional<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>
getEnumConverter( const VariableSet& vs, const std::string& name );
 
template <typename Enum, typename std::enable_if<std::is_enum<Enum> {}, bool>::type = true>
std::string getEnumString( const VariableSet& vs, const std::string& name, Enum value );
 
template <typename EnumBaseType>
std::string
getEnumString( const VariableSet& vs,
               const std::string& name,
               EnumBaseType value,
               typename std::enable_if<!std::is_enum<EnumBaseType> {}, bool>::type = true );
 
void RA_CORE_API setEnumVariable( VariableSet& vs,
                                  const std::string& name,
                                  const std::string& value );
 
void RA_CORE_API setEnumVariable( VariableSet& vs, const std::string& name, const char* value );
 
template <typename T>
void setEnumVariable( VariableSet& vs, const std::string& name, T value ) {
    auto v = static_cast<typename std::underlying_type<T>::type>( value );
    vs.setVariable( name, v );
}
 
template <typename T>
auto getEnumVariable( const VariableSet& vs, const std::string& name ) -> const T& {
    static_assert( std::is_enum<T>::value );
    return reinterpret_cast<const T&>(
        vs.getVariable<typename std::underlying_type<T>::type>( name ) );
}
 
template <typename T>
auto getEnumVariable( VariableSet& vs, const std::string& name ) -> T& {
    return const_cast<T&>( getEnumVariable<T>( const_cast<const VariableSet&>( vs ), name ) );
}
 
template <typename EnumBaseType>
void addEnumConverter( VariableSet& vs,
                       const std::string& name,
                       std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>> converter ) {
 
    // typed converter
    auto converterHandle = vs.setVariable( name, converter );
 
    // string string converter/setter for setEnumVariable
    std::function<void( Core::VariableSet&, const std::string&, const std::string& )>
        convertingFunction = [converter_ = converterHandle.first]( Core::VariableSet& vs_,
                                                                   const std::string& name_,
                                                                   const std::string& value_ ) {
            vs_.setVariable( name_, converter_->second->getEnumerator( value_ ) );
        };
    vs.setVariable( name, convertingFunction );
}
 
template <typename EnumBaseType>
Core::Utils::optional<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>
getEnumConverter( const VariableSet& vs, const std::string& name ) {
    auto storedConverter =
        vs.existsVariable<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>( name );
    if ( storedConverter ) { return ( *storedConverter )->second; }
    return {};
}
 
template <typename EnumBaseType>
std::string getEnumString( const VariableSet& vs,
                           const std::string& name,
                           EnumBaseType value,
                           typename std::enable_if<!std::is_enum<EnumBaseType> {}, bool>::type ) {
    auto storedConverter =
        vs.existsVariable<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>( name );
    if ( storedConverter ) { return ( *storedConverter )->second->getEnumerator( value ); }
    LOG( Ra::Core::Utils::logWARNING ) << name + " is not a registered Enum with underlying type " +
                                              Ra::Core::Utils::demangleType<EnumBaseType>() + ".";
    return "";
}
 
template <typename Enum, typename std::enable_if<std::is_enum<Enum> {}, bool>::type>
std::string getEnumString( const VariableSet& vs, const std::string& name, Enum value ) {
    using EnumBaseType = typename std::underlying_type_t<Enum>;
    return getEnumString( vs, name, EnumBaseType( value ) );
}
 
} // namespace VariableSetEnumManagement
} // namespace Core
} // namespace Ra