spell_composition.hpp

Go to the documentation of this file.

#pragma once
 
#include "spell_base.hpp"
#include <string>
#include <utility>
#include "rune_sequence.hpp"
 
namespace rune_caster {
 
namespace spell {
namespace composition {

template<typename FirstSpell, typename SecondSpell>
class SpellComposition : public sequence_spell {
    static_assert(spell_concept<FirstSpell>, "FirstSpell must satisfy spell_concept");
    static_assert(spell_concept<SecondSpell>, "SecondSpell must satisfy spell_concept");
    static_assert(chainable_spells<FirstSpell, SecondSpell>, "Spells must be chainable");
 
private:
    FirstSpell first_spell_;
    SecondSpell second_spell_;
    std::string description_;
 
public:
    using input_type = typename FirstSpell::input_type;
    using output_type = typename SecondSpell::output_type;

    constexpr SpellComposition(FirstSpell first, SecondSpell second)
        : first_spell_(std::move(first))
        , second_spell_(std::move(second))
        , description_(first_spell_.description() + " → " + second_spell_.description())
    {
        static_assert(std::same_as<typename FirstSpell::output_type, typename SecondSpell::input_type>,
                     "Output type of first spell must match input type of second spell");
    }

    output_type operator()(const input_type& input) const override {
        auto intermediate = first_spell_(input);
        return second_spell_(intermediate);
    }
 
    std::string description() const override {
        return description_;
    }
 
    std::string name() const override {
        return first_spell_.name() + "→" + second_spell_.name();
    }

    const FirstSpell& first_spell() const noexcept { return first_spell_; }

    const SecondSpell& second_spell() const noexcept { return second_spell_; }
};

template<typename FirstSpell, typename SecondSpell>
auto compose(FirstSpell&& first, SecondSpell&& second) {
    static_assert(spell_concept<FirstSpell>, "FirstSpell must satisfy spell_concept");
    static_assert(spell_concept<SecondSpell>, "SecondSpell must satisfy spell_concept");
    static_assert(chainable_spells<FirstSpell, SecondSpell>, "Spells must be chainable");
 
    return SpellComposition<std::decay_t<FirstSpell>, std::decay_t<SecondSpell>>{
        std::forward<FirstSpell>(first),
        std::forward<SecondSpell>(second)
    };
}

template<typename Spell>
RuneSequence cast_spell(const RuneSequence& input, const Spell& spell) {
    static_assert(spell_for<Spell, RuneSequence>, "Spell must accept RuneSequence as input");
    return spell(input);
}

template<typename Spell>
std::string cast_spell(std::string_view utf8_input, const Spell& spell) {
    static_assert(spell_for<Spell, RuneSequence>, "Spell must accept RuneSequence as input");
    static_assert(std::same_as<typename Spell::output_type, RuneSequence>,
                 "Spell must output RuneSequence for string conversion");
 
    auto sequence = RuneSequence::from_utf8(utf8_input);
    auto result = spell(sequence);
    return result.to_utf8();
}
 
} // namespace composition
 
// Import composition utilities into the main spell namespace for convenience
using composition::SpellComposition;
using composition::compose;
using composition::cast_spell;
 
} // namespace spell
} // namespace rune_caster