spell_base.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <type_traits>
#include <concepts>
#include <functional>
#include <utility>
#include <ranges>
 
#include "rune_sequence.hpp"
 
namespace rune_caster {
 
// Forward declarations removed to avoid conflict; RuneSequence is defined via alias later.

template<typename Input, typename Output = Input>
class spell_base {
public:
    using input_type = Input;
    using output_type = Output;
 
    virtual ~spell_base() = default;

    virtual output_type operator()(const input_type& input) const = 0;

    virtual std::string name() const = 0;

    virtual std::string description() const = 0;

    template<typename T>
    static constexpr bool can_process() noexcept {
        return std::same_as<T, input_type> || std::convertible_to<T, input_type>;
    }

    template<typename T>
    static constexpr bool produces() noexcept {
        return std::same_as<T, output_type> || std::convertible_to<output_type, T>;
    }

    static constexpr const char* input_type_name() noexcept {
        return typeid(input_type).name();
    }

    static constexpr const char* output_type_name() noexcept {
        return typeid(output_type).name();
    }
};

using sequence_spell = spell_base<RuneSequence>;
 
// C++20 Concepts - Modern Type Checking

template<typename T>
concept spell_concept = requires(T spell) {
    typename T::input_type;
    typename T::output_type;
    { spell.name() } -> std::convertible_to<std::string>;
    { spell.description() } -> std::convertible_to<std::string>;
    requires std::invocable<T, typename T::input_type>;
    requires std::same_as<
        std::invoke_result_t<T, typename T::input_type>,
        typename T::output_type
    >;
};

template<typename Spell, typename Input>
concept spell_for = spell_concept<Spell> &&
                   std::same_as<typename Spell::input_type, Input>;

template<typename T>
concept sequence_spell_concept = spell_for<T, RuneSequence> &&
                                std::same_as<typename T::output_type, RuneSequence>;

template<typename Spell, typename Input, typename Output>
concept transforming_spell = spell_concept<Spell> &&
                           spell_for<Spell, Input> &&
                           std::same_as<typename Spell::output_type, Output>;

template<typename Spell1, typename Spell2>
concept chainable_spells = spell_concept<Spell1> &&
                          spell_concept<Spell2> &&
                          (std::same_as<typename Spell1::output_type, typename Spell2::input_type> ||
                           std::convertible_to<typename Spell1::output_type, typename Spell2::input_type>);
 
// Backward compatibility - convert concepts to constexpr bool
template<typename T>
constexpr bool is_spell_v = spell_concept<T>;
 
template<typename Spell, typename Input>
constexpr bool can_spell_process_v = spell_for<Spell, Input>;
 
template<typename Spell1, typename Spell2>
constexpr bool chainable_v = chainable_spells<Spell1, Spell2>;
 
template<typename T>
constexpr bool is_sequence_spell_v = sequence_spell_concept<T>;
 
} // namespace rune_caster