mgl_text_character.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_TEXT_CHARACTER_H_1538587141
#define INCGUARD_MGL_TEXT_CHARACTER_H_1538587141
 
#include <cstddef>
#include <cstdint>
 
#include <mgl/stl/mgl_stl_containers.h>
#include <mgl/stl/mgl_stl_string.h>
 
namespace MGL::Text
{
class Character
{
public:
    static constexpr uint32_t kInvalidMarkerBit = 1UL << 31UL;
 
    static constexpr uint32_t kValidateMask = 0xFFFFFFFF & ~kInvalidMarkerBit;
 
    static constexpr size_t kByteArraySize = 5;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Character(uint32_t code) noexcept
        : _code(code)
    {
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr char32_t GetCode() const noexcept
    {
        return static_cast<char32_t>(_code & kValidateMask);
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetCode(char32_t code) noexcept
    {
        _code = static_cast<uint32_t>(code);
 
        if (_code > 0x10FFFF)
        {
            SetInvalidMarker();
        }
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetInvalidMarker() noexcept
    {
        _code |= kInvalidMarkerBit;
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsValid() const noexcept
    {
        return ((_code & kInvalidMarkerBit) == 0);
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsNull() const noexcept
    {
        return (GetCode() == 0);
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsNewLine() const noexcept
    {
        return ((_code == 0x0D) || (_code == 0x0A));
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsSpace() const noexcept
    {
        return ((_code == ' ') || (_code == '\t'));
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsDigit() const noexcept
    {
        return ((_code >= '0') && (_code <= '9'));
    }
 
    [[nodiscard]] size_t GetByteSize() const noexcept;
    bool ToByte(char byteArray[kByteArraySize]) const noexcept;
    char *ToByte(char *dest, size_t destSize) const noexcept;
    [[nodiscard]] STL::string ToString() const noexcept;
 
private:
    uint32_t _code;
};
 
 
class CharacterArray : public STL::vector<Character>
{
public:
    [[nodiscard]] STL::string ToString() const;
    [[nodiscard]] STL::string ToString(uint32_t start, uint32_t end) const;
 
    [[nodiscard]] int Find(uint32_t findCode, uint32_t start = 0) const;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    reference at(size_type n)
    {
        return (n >= size()) ? _endCode : STL::vector<Character>::at(n);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] const_reference at(size_type n) const
    {
        return (n >= size()) ? _endCode : STL::vector<Character>::at(n);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] reference operator[](size_type pos) noexcept
    {
        return CharacterArray::at(pos);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] const_reference operator[](size_type pos) const noexcept
    {
        return CharacterArray::at(pos);
    }
 
private:
    inline static Character _endCode{'\0'};
};
}    // namespace MGL::Text
 
#endif    // INCGUARD_MGL_TEXT_CHARACTER_H_1538587141
 
// vim: et ts=4 sw=4 sts=4