caster.hpp

Go to the documentation of this file.

#pragma once
 
#include "spell_base.hpp"
#include "rune_sequence.hpp"
#include <type_traits>
#include <utility>
#include <concepts>
 
namespace rune_caster {

template<typename T>
class caster {
private:
    T data_;
    
public:
    using value_type = T;
    
    template<typename U>
    explicit constexpr caster(U&& data) 
        noexcept(std::is_nothrow_constructible_v<T, U>)
        : data_(std::forward<U>(data)) {}
    
    template<spell_for<T> Spell>
    constexpr auto cast(Spell&& spell) const & -> caster<typename Spell::output_type> {
        return caster<typename Spell::output_type>{spell(data_)};
    }
    
    template<spell_for<T> Spell>
    constexpr auto cast(Spell&& spell) && -> caster<typename Spell::output_type> {
        return caster<typename Spell::output_type>{spell(std::move(data_))};
    }
    
    constexpr const T& result() const & noexcept {
        return data_;
    }
    
    constexpr T&& result() && noexcept {
        return std::move(data_);
    }
    
    constexpr T result() const && {
        return data_;
    }
    
    constexpr const T& operator*() const & noexcept {
        return data_;
    }
    
    constexpr T&& operator*() && noexcept {
        return std::move(data_);
    }
    
    constexpr explicit operator bool() const noexcept {
        if constexpr (std::is_pointer_v<T>) {
            return data_ != nullptr;
        } else if constexpr (requires { data_.empty(); }) {
            return !data_.empty();
        } else {
            return true;  // For non-pointer, non-container types are always valid
        }
    }
    
    static constexpr const char* type_name() noexcept {
        return typeid(T).name();
    }
};

template<typename T>
constexpr auto make_caster(T&& data) noexcept -> caster<std::decay_t<T>> {
    return caster<std::decay_t<T>>{std::forward<T>(data)};
}

template<typename T, spell_concept Spell>
    requires spell_for<Spell, std::decay_t<T>> || 
             (requires { RuneSequence::from_utf8(std::declval<T>()); } && 
              spell_for<Spell, RuneSequence>)
constexpr auto operator|(T&& data, Spell&& spell) {
    if constexpr (spell_for<Spell, std::decay_t<T>>) {
        return make_caster(std::forward<T>(data))
               .cast(std::forward<Spell>(spell))
               .result();
    } else {
        return make_caster(RuneSequence::from_utf8(data))
               .cast(std::forward<Spell>(spell))
               .result();
    }
}

template<typename T, spell_for<T> Spell>
constexpr auto operator|(caster<T>&& caster_obj, Spell&& spell) {
    return std::move(caster_obj).cast(std::forward<Spell>(spell));
}
 
} // namespace rune_caster