spell_factory.hpp

Go to the documentation of this file.

#pragma once
 
#include "spell_core.hpp"
#include "spell_filter.hpp"
#include "spell_composition.hpp"
#include "unicode.hpp"
#include "spell_token.hpp"
 
namespace rune_caster {
namespace spell {
namespace factory {

 
// === Whitespace normalization factories ===

inline auto whitespace() {
    return core::WhitespaceNormalizer{};
}

inline auto whitespace(bool collapse_multiple, bool trim_edges = true) {
    return core::WhitespaceNormalizer{collapse_multiple, trim_edges};
}
 
// === Case conversion factories ===

inline auto lowercase() {
    return core::CaseConverter{core::CaseConverter::CaseType::Lower};
}

inline auto uppercase() {
    return core::CaseConverter{core::CaseConverter::CaseType::Upper};
}

inline auto titlecase() {
    return core::CaseConverter{core::CaseConverter::CaseType::Title};
}
 
// === Unicode normalization factories ===

inline auto unicode_nfc() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFC};
}

inline auto unicode_nfd() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFD};
}

inline auto unicode_nfkc() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFKC};
}

inline auto unicode_nfkd() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFKD};
}
 
// === Punctuation filter factories ===

inline auto punctuation(bool remove = true) {
    return filter::PunctuationFilter{remove};
}
 
// === Combined operation factories ===

template<typename CaseType = void>
auto text_normalizer(CaseType case_type = {}) {
    if constexpr (std::is_void_v<CaseType>) {
        return compose(whitespace(), unicode_nfc());
    } else {
        return compose(
            compose(whitespace(), unicode_nfc()),
            core::CaseConverter{case_type}
        );
    }
}

inline auto search_preprocessor() {
    return compose(
        compose(whitespace(), unicode_nfc()),
        lowercase()
    );
}

inline auto display_formatter() {
    return compose(
        compose(whitespace(), unicode_nfc()),
        titlecase()
    );
}

template<bool RemovePunctuation = true>
inline auto text_normalizer_with_punctuation() {
    if constexpr (RemovePunctuation) {
        return compose(compose(whitespace(), unicode_nfc()), punctuation(true));
    } else {
        return compose(whitespace(), unicode_nfc());
    }
}
 
// === Trim factory ===
inline auto trim() { return core::TrimEdges{}; }
 
// === Tokenizer factory ===
inline auto tokenizer_whitespace() { return core::WhitespaceTokenizer{}; }
 
} // namespace factory
 
// Import factory functions into the main spell namespace for convenience
using namespace factory;
 
} // namespace spell
} // namespace rune_caster