rune.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <string>
#include <string_view>
 
#include "unicode.hpp"
#include "language.hpp"
 
namespace rune_caster {

class Rune {
public:
    // === Constructors (C++20 constexpr enhanced) ===

    constexpr Rune() noexcept;

    constexpr explicit Rune(char32_t codepoint) noexcept;

    constexpr Rune(char32_t codepoint, language::Code lang) noexcept;

    Rune(char32_t codepoint, language::Code lang, std::string phoneme);
 
    // === Copy/Move semantics ===
    constexpr Rune(const Rune&) = default;
    constexpr Rune(Rune&&) noexcept = default;
    constexpr Rune& operator=(const Rune&) = default;
    constexpr Rune& operator=(Rune&&) noexcept = default;
    ~Rune() = default;
 
    // === Accessors (C++20 constexpr) ===

    [[nodiscard]] constexpr char32_t codepoint() const noexcept { return codepoint_; }

    [[nodiscard]] constexpr language::Code language() const noexcept { return language_; }

    [[nodiscard]] constexpr unicode::Category category() const noexcept;

    [[nodiscard]] constexpr unicode::Script script() const noexcept;

    [[nodiscard]] const std::string& phoneme() const noexcept { return phoneme_; }
 
    // === Mutators ===

    constexpr void set_language(language::Code lang) noexcept { language_ = lang; }

    void set_phoneme(std::string phoneme) { phoneme_ = std::move(phoneme); }
 
    // === Enhanced Character classification (C++20 constexpr) ===

    [[nodiscard]] constexpr bool is_vowel() const noexcept;

    [[nodiscard]] constexpr bool is_consonant() const noexcept;

    [[nodiscard]] constexpr bool is_letter() const noexcept;

    [[nodiscard]] constexpr bool is_digit() const noexcept;

    [[nodiscard]] constexpr bool is_whitespace() const noexcept;

    [[nodiscard]] constexpr bool is_punctuation() const noexcept;
 
    // === Language-specific properties (API Design Document requirement) ===

    [[nodiscard]] constexpr bool is_ascii() const noexcept;

    [[nodiscard]] constexpr bool is_latin() const noexcept;

    [[nodiscard]] constexpr bool is_hangul() const noexcept;

    [[nodiscard]] constexpr bool is_hiragana() const noexcept;

    [[nodiscard]] constexpr bool is_katakana() const noexcept;

    [[nodiscard]] constexpr bool is_kanji() const noexcept;

    [[nodiscard]] constexpr bool is_emoji() const noexcept;
 
    // === Conversion ===

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

    [[nodiscard]] std::u16string to_utf16() const;

    [[nodiscard]] constexpr std::u32string to_utf32() const;
 
    // === Factory methods (API Design Document requirement) ===

    static Rune from_utf8(std::string_view utf8_char);

    static Rune from_utf8(std::string_view utf8_char, language::Code lang);

    static Rune from_utf16(std::u16string_view utf16_char);
 
    // === Comparison operators (C++20 three-way comparison) ===

    [[nodiscard]] constexpr auto operator<=>(const Rune& other) const noexcept = default;

    [[nodiscard]] constexpr bool operator==(const Rune& other) const noexcept = default;
 
private:
    char32_t codepoint_;        
    language::Code language_;   
    std::string phoneme_;       

    static constexpr language::Code detect_language(char32_t cp) noexcept;
};
 
// === User-defined literals (API Design Document requirement) ===

constexpr Rune operator""_rune(char32_t cp) noexcept {
    return Rune(cp);
}
 
// === Inline definitions for constructors (header-level) ===
inline constexpr Rune::Rune() noexcept : codepoint_(U'\0'), language_(language::Code::Unknown), phoneme_() {}
inline constexpr Rune::Rune(char32_t codepoint) noexcept : codepoint_(codepoint), language_(Rune::detect_language(codepoint)), phoneme_() {}
inline constexpr Rune::Rune(char32_t codepoint, language::Code lang) noexcept : codepoint_(codepoint), language_(lang), phoneme_() {}
 
// === Inline definitions for classification methods ===
inline constexpr bool Rune::is_letter() const noexcept { return unicode::is_letter(codepoint_); }
inline constexpr bool Rune::is_digit() const noexcept { return unicode::is_digit(codepoint_); }
inline constexpr bool Rune::is_whitespace() const noexcept { return unicode::is_whitespace(codepoint_); }
inline constexpr bool Rune::is_punctuation() const noexcept { return unicode::is_punctuation(codepoint_); }
 
// === Language detection (inline implementation) ===
inline constexpr language::Code Rune::detect_language(char32_t cp) noexcept {
    // Korean (Hangul)
    if ((cp >= 0x1100 && cp <= 0x11FF) ||  // Hangul Jamo
        (cp >= 0x3130 && cp <= 0x318F) ||  // Hangul Compatibility Jamo
        (cp >= 0xAC00 && cp <= 0xD7AF)) {  // Hangul Syllables
        return language::Code::Korean;
    }
    
    // Japanese
    if ((cp >= 0x3040 && cp <= 0x309F) ||  // Hiragana
        (cp >= 0x30A0 && cp <= 0x30FF) ||  // Katakana
        (cp >= 0x31F0 && cp <= 0x31FF)) {  // Katakana Phonetic Extensions
        return language::Code::Japanese;
    }
    
    // Chinese (CJK Ideographs)
    if ((cp >= 0x4E00 && cp <= 0x9FFF) ||  // CJK Unified Ideographs
        (cp >= 0x3400 && cp <= 0x4DBF) ||  // CJK Extension A
        (cp >= 0x20000 && cp <= 0x2A6DF)) { // CJK Extension B
        return language::Code::Chinese;
    }
    
    // English/Latin
    if ((cp <= 0x024F) ||                   // Basic Latin + Latin Extended
        (cp >= 0x1E00 && cp <= 0x1EFF)) {  // Latin Extended Additional
        return language::Code::English;
    }
    
    return language::Code::Unknown;
}
inline constexpr bool Rune::is_vowel() const noexcept {
    char32_t c = codepoint_;
    
    // 라틴 알파벳 모음 (영어)
    if (c == U'a' || c == U'e' || c == U'i' || c == U'o' || c == U'u' ||
        c == U'A' || c == U'E' || c == U'I' || c == U'O' || c == U'U') {
        return true;
    }
    
    // 한글 모음 (ㅏ-ㅣ 범위)
    if (c >= U'ㅏ' && c <= U'ㅣ') {
        return true;
    }
    
    // 일본어 모음 (히라가나)
    if (c == U'あ' || c == U'い' || c == U'う' || c == U'え' || c == U'お') {
        return true;
    }
    
    // 일본어 모음 (가타카나)
    if (c == U'ア' || c == U'イ' || c == U'ウ' || c == U'エ' || c == U'オ') {
        return true;
    }
    
    return false;
}
inline constexpr bool Rune::is_consonant() const noexcept {
    return is_letter() && !is_vowel();
}
// inline definitions for previously constexpr functions already specialized in rune.cpp (will be identical)
 
} // namespace rune_caster