Как я могу уменьшить специализацию шаблонов функций?

Question

Я пытаюсь написать средство проверки свойств для использования в UE4, используя их систему отражения. Сначала я придумал следующее:

class FDataValidator
{
public:
    FDataValidator( UObject & object, TArray< FText > & validation_errors ) :
        Object( object ),
        ValidationResult( validation_errors.Num() == 0 ? EDataValidationResult::Valid : EDataValidationResult::Invalid ),
        ObjectClass( Object.GetClass() ),
        ValidationErrors( validation_errors )
    {}

    template < class _TYPE_ >
    FDataValidator & GreaterThan( const FName property_name, const _TYPE_ value );

    EDataValidationResult Result() const
    {
        return ValidationResult;
    }

private:
    template < class _PROPERTY_TYPE_, class _VALUE_TYPE_, class _COMPARATOR_TYPE_ >
    FDataValidator & CompareProperty( const FName property_name, const _VALUE_TYPE_ value, _COMPARATOR_TYPE_ comparator = _COMPARATOR_TYPE_() )
    {
        if ( auto * property = GetTypedProperty< _PROPERTY_TYPE_ >( property_name ) )
        {
            const auto property_value = property->GetPropertyValue_InContainer( &Object );

            if ( !comparator( property_value, value ) )
            {
                AddError( FText::FromString( FString::Printf( TEXT( "%s must be greater than %f" ), *property_name.ToString(), value ) ) );
            }
        }

        return *this;
    }

    template < class _PROPERTY_TYPE_ >
    _PROPERTY_TYPE_ * GetTypedProperty( const FName property_name )
    {
        if ( auto * property = ObjectClass->FindPropertyByName( property_name ) )
        {
            if ( auto * typed_property = Cast< _PROPERTY_TYPE_ >( property ) )
            {
                return typed_property;
            }
        }

        return nullptr;
    }

    void AddError( FText text )
    {
        ValidationErrors.Emplace( text );
        ValidationResult = EDataValidationResult::Invalid;
    }

    UObject & Object;
    EDataValidationResult ValidationResult;
    UClass * ObjectClass;
    TArray< FText > & ValidationErrors;
};

template <>
FDataValidator & FDataValidator::GreaterThan< float >( const FName property_name, const float value )
{
    return CompareProperty< UFloatProperty, float, std::greater< float > >( property_name, value );
}

template <>
FDataValidator & FDataValidator::GreaterThan< int >( const FName property_name, const int value )
{
    return CompareProperty< UIntProperty, int, std::greater< int > >( property_name, value );
}

Я реализовал GreaterThan только для 2-х типов и хотел бы знать, не могу ли я реорганизовать класс, чтобы избежать стольких специализаций шаблонов.

Возможно ли иметь что-то подобное, где я передаю, например, std::greater< _VALUE_TYPE_ > и позволяю системе сделать вывод, что _VALUE_TYPE_ должен вызвать GetTypedProperty с правильным типом?

class FDataValidator
{
public:
    template < class _VALUE_TYPE_ >
    FDataValidator & GreaterThan( const FName property_name, const _VALUE_TYPE_ value )
    {
        return NumericComparator< std::greater< _VALUE_TYPE_ > >( property_name, value );
    }

private:

    // How to write this to infer for example that _VALUE_TYPE_ is float when passed std::greater< float > ?
    template < typename _COMPARATOR_TYPE_ >
    FDataValidator & NumericComparator( FName property_name, _VALUE_TYPE_ value, _COMPARATOR_TYPE_ comparator = _COMPARATOR_TYPE_() );
};

template < class _VALUE_TYPE_, class _COMPARATOR_TYPE_ >
FDataValidator & NumericComparator( FName property_name, _VALUE_TYPE_ value, _COMPARATOR_TYPE_ comparator = _COMPARATOR_TYPE_() )
{
    return CompareProperty< UFloatProperty, float, std::greater< float > >( property_name, value );
}

Спасибо

Answer 1

UFloatProperty и другие числовые типы c кажутся наследниками от TProperty_Numeric<T>. Решением может быть что-то вроде этого:

template <typename T>
FDataValidator& FDataValidator::GreaterThan<T>(const FName property_name, const T value)
{
    return CompareProperty<TProperty_Numeric<T>, T, std::greater<T>>(property_name, value);
}