spell_unified.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <string>
#include <string_view>
#include <memory>
#include <type_traits>
 
#include "rune_sequence.hpp"
#include "caster.hpp"
 
namespace rune_caster {

class Spell {
public:
    // === Type definitions ===
    using transform_function = std::function<RuneSequence(const RuneSequence&)>;
    using validation_function = std::function<bool(const RuneSequence&)>;
 
    // === Constructors ===

    Spell() noexcept;

    explicit Spell(transform_function transform,
                   std::string name = "CustomSpell",
                   std::string description = "User-defined transformation");

    template<typename Func>
    requires std::invocable<Func, const RuneSequence&> &&
             std::convertible_to<std::invoke_result_t<Func, const RuneSequence&>, RuneSequence>
    explicit Spell(Func&& func,
                   std::string name = "LambdaSpell",
                   std::string description = "Lambda transformation")
        : transform_(std::forward<Func>(func))
        , name_(std::move(name))
        , description_(std::move(description))
        , id_(generate_id()) {}
 
    // === Copy/Move semantics ===
    Spell(const Spell&) = default;
    Spell(Spell&&) noexcept = default;
    Spell& operator=(const Spell&) = default;
    Spell& operator=(Spell&&) noexcept = default;
    ~Spell() = default;
 
    // === Core transformation ===

    RuneSequence operator()(const RuneSequence& input) const;

    std::string operator()(std::string_view utf8_input) const;
 
    // === Pipeline composition ===

    Spell operator|(const Spell& next) const;
 
    // Note: Only one operator| definition to avoid ambiguity
 
    // === Accessors ===

    [[nodiscard]] const std::string& name() const noexcept { return name_; }

    [[nodiscard]] const std::string& description() const noexcept { return description_; }

    [[nodiscard]] uint64_t id() const noexcept { return id_; }
 
    // === Validation and properties ===

    [[nodiscard]] bool is_identity() const noexcept;

    [[nodiscard]] bool is_composition() const noexcept { return is_composition_; }

    [[nodiscard]] size_t composition_depth() const noexcept { return composition_depth_; }
 
    // === Debugging and introspection ===

    [[nodiscard]] std::string to_string() const;

    RuneSequence test(const RuneSequence& test_input) const;
 
    // === Static factory methods ===

    static Spell identity();

    static Spell constant(RuneSequence constant_result);

    static Spell conditional(validation_function condition,
                           const Spell& if_true,
                           const Spell& if_false);
 
private:
    transform_function transform_;     
    std::string name_;                
    std::string description_;         
    uint64_t id_;                    
    bool is_composition_;            
    size_t composition_depth_;       

    static uint64_t generate_id();
};
 
// === Factory functions for common spells ===
 
namespace spell_factory {

template<typename Lambda>
auto make_spell(Lambda&& lambda,
                std::string name = "CustomSpell",
                std::string description = "Custom transformation") {
    return Spell{std::forward<Lambda>(lambda), std::move(name), std::move(description)};
}

template<typename RuneTransform>
auto per_rune_spell(RuneTransform&& rune_transform,
                   std::string name = "PerRuneSpell",
                   std::string description = "Per-rune transformation") {
    return make_spell([transform = std::forward<RuneTransform>(rune_transform)]
                     (const RuneSequence& input) -> RuneSequence {
        RuneSequence result;
        for (const auto& rune : input) {
            result.append(transform(rune));
        }
        return result;
    }, std::move(name), std::move(description));
}

template<typename Predicate>
auto filter_spell(Predicate&& predicate,
                 std::string name = "FilterSpell",
                 std::string description = "Rune filtering") {
    return make_spell([pred = std::forward<Predicate>(predicate)]
                     (const RuneSequence& input) -> RuneSequence {
        RuneSequence result;
        for (const auto& rune : input) {
            if (pred(rune)) {
                result.append(rune);
            }
        }
        return result;
    }, std::move(name), std::move(description));
}
 
} // namespace spell_factory
 
// === Integration with Caster ===
// Note: Caster integration will be handled in caster.hpp
 
} // namespace rune_caster
 
// === User-defined literals ===
 
namespace rune_caster::literals {

Spell operator""_spell(const char* replacement_rule, size_t len);
 
} // namespace rune_caster::literals