box_char.hpp

Go to the documentation of this file.

#pragma once
#include "box.hpp"
#include "char32.hpp"
#include "character.hpp"

namespace xtd {
  template<typename type_t>
  requires xtd::character<type_t>
  class box_char : public xtd::box<type_t> {
  public:
    box_char() = default;
    box_char(const type_t& value) : box<type_t>(value) {}
    box_char(const box_char&) = default;
    box_char(box_char&&) = default;
    box_char& operator =(const box_char&) = default;
    
    
    static constexpr type_t max_value = std::numeric_limits<type_t>::max();
    static constexpr type_t min_value = std::numeric_limits<type_t>::lowest();

    
    [[nodiscard]] static auto is_ascii(type_t c) noexcept -> bool {return c > 0 && c <= 0x7F;}
    [[nodiscard]] static auto is_ascii(const string& s, size_t index) -> bool {return is_ascii(s[index]);}
    
    [[nodiscard]] static auto is_control(type_t c) noexcept -> bool {return std::iscntrl(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_control(const string& s, size_t index) -> bool {return is_control(s[index]);}
    
    [[nodiscard]] static auto is_digit(type_t c) noexcept -> bool {return std::isdigit(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_digit(const string& s, size_t index) -> bool {return is_digit(s[index]);}
    
    [[nodiscard]] static auto is_letter(type_t c) noexcept -> bool {return std::isalpha(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_letter(const string& s, size_t index) -> bool {return is_letter(s[index]);}
    
    [[nodiscard]] static auto is_letter_or_digit(type_t c) noexcept -> bool {return std::isalnum(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_letter_or_digit(const string& s, size_t index) -> bool {return is_letter_or_digit(s[index]);}
    
    [[nodiscard]] static auto is_lower(type_t c) noexcept -> bool {return std::islower(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_lower(const string& s, size_t index) -> bool {return is_lower(s[index]);}
    
    [[nodiscard]] static auto is_number(type_t c) noexcept -> bool {return std::isdigit(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_number(const string& s, size_t index) -> bool {return is_number(s[index]);}
    
    [[nodiscard]] static auto is_punctuation(type_t c) noexcept -> bool {return std::ispunct(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_punctuation(const string& s, size_t index) -> bool {return is_punctuation(s[index]);}
    
    [[nodiscard]] static auto is_separator(type_t c) noexcept -> bool {return std::isspace(static_cast<int>(c)) != 0 || c == '\n';}
    [[nodiscard]] static auto is_separator(const string& s, size_t index) -> bool {return is_separator(s[index]);}
    
    [[nodiscard]] static auto is_symbol(type_t c) noexcept -> bool {return std::isgraph(static_cast<int>(c)) != 0 || c == 0x9C;}
    [[nodiscard]] static auto is_symbol(const string& s, size_t index) -> bool {return is_symbol(s[index]);}
    
    [[nodiscard]] static auto is_upper(type_t c) noexcept -> bool {return std::isupper(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_upper(const string& s, size_t index) -> bool {return is_upper(s[index]);}
    
    [[nodiscard]] static auto is_valid(type_t value) noexcept -> bool {return value >= static_cast<xtd::char32>(min_value) && value <= static_cast<xtd::char32>(max_value);}

    [[nodiscard]] static auto is_white_space(type_t c) noexcept -> bool {return std::isspace(static_cast<int>(c)) != 0;}
    [[nodiscard]] static auto is_white_space(const string& s, size_t index) -> bool {return is_white_space(s[index]);}
    
    using box<type_t>::parse;
    static type_t parse(const xtd::string& value, xtd::number_styles styles) {return xtd::parse<type_t>(value, styles);}

    [[nodiscard]] static auto to_lower(type_t c) noexcept -> type_t {return static_cast<type_t>(std::tolower(static_cast<int>(c)));}
    
    [[nodiscard]] static auto to_upper(type_t c) noexcept -> type_t {return static_cast<type_t>(std::toupper(static_cast<int>(c)));}
    
    using box<type_t>::try_parse;
    static bool try_parse(const xtd::string& value, type_t& result, xtd::number_styles styles) {return xtd::try_parse<type_t>(value, result, styles);}
  };
}