Character.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_TYPE__CHARACTER
#define COM_BORA_SOFTWARE__BALAU_TYPE__CHARACTER

#include <Balau/Type/StdTypes.hpp>

#include <unicode/uchar.h>
#include <unicode/utf8.h>

namespace Balau {

struct Character {

    static bool isLower(char32_t c) {
        return u_islower((UChar32) c);
    }

    static bool isUpper(char32_t c) {
        return u_isupper((UChar32) c);
    }

    static bool isDigit(char32_t c) {
        return u_isdigit((UChar32) c);
    }

    static bool isHexDigit(char32_t c) {
        return c <= 0x7f && u_isxdigit((UChar32) c);
    }

    static bool isOctalDigit(char32_t c) {
        return c >= U'0' && c <= U'9';
    }

    static bool isBinaryDigit(char32_t c) {
        return c == U'0' || c == U'1';
    }

    static bool isAlpha(char32_t c) {
        return u_isalpha((UChar32) c);
    }

    static bool isAlphaOrDecimal(char32_t c) {
        return u_isalnum((UChar32) c);
    }

    static bool isControlCharacter(char32_t c) {
        return u_iscntrl((UChar32) c);
    }

    static bool isSpace(char32_t c) {
        return u_isJavaSpaceChar((UChar32) c);
    }

    static bool isWhitespace(char32_t c) {
        return u_isWhitespace((UChar32) c);
    }

    static bool isBlank(char32_t c) {
        return u_isblank((UChar32) c);
    }

    static bool isPrintable(char32_t c) {
        return u_isprint((UChar32) c);
    }

    static bool isPunctuation(char32_t c) {
        return u_ispunct((UChar32) c);
    }

    static bool isIdStart(char32_t c) {
        return u_isIDStart((UChar32) c);
    }

    static bool isIdPart(char32_t c) {
        return u_isIDPart((UChar32) c);
    }

    static bool isBreakableCharacter(char32_t c) {
        return (u_isWhitespace((UChar32) c) || c == U'-');
    }

    static bool isInclusiveBreakableCharacter(char32_t c) {
        return c == U'-';
    }

    static size_t utf8ByteCount(char32_t c) {
        return U8_LENGTH((UChar32) c);
    }


    static char32_t getNextUtf8(const std::string_view & text, int & offset) {
        UChar32 newUChar;
        U8_NEXT_UNSAFE(text.data(), offset, newUChar); // NOLINT
        return (char32_t) newUChar;
    }

    static char32_t getNextUtf8Safe(const std::string_view & text, int & offset) {
        UChar32 newUChar;
        U8_NEXT(text.data(), offset, (int32_t) text.length(), newUChar); // NOLINT
        return (char32_t) newUChar;
    }

    static char32_t getPreviousUtf8(const std::string_view & text, int & offset) {
        UChar32 newUChar;
        U8_PREV_UNSAFE(text.data(), offset, newUChar); // NOLINT
        return (char32_t) newUChar;
    }

    static char32_t getPreviousUtf8Safe(const std::string_view & text, int & offset) {
        UChar32 newUChar;
        U8_PREV(text.data(), 0, offset, newUChar); // NOLINT
        return (char32_t) newUChar;
    }

    static void advanceUtf8(const std::string_view & text, int & offset) {
        U8_FWD_1_UNSAFE(text.data(), offset); // NOLINT
    }

    static void advanceUtf8Safe(const std::string_view & text, int & offset) {
        U8_FWD_1(text.data(), offset, ((int32_t) text.length())); // NOLINT
    }

    static void retreatUtf8(const std::string_view & text, int & offset) {
        U8_BACK_1_UNSAFE(text.data(), offset);
    }

    static void retreatUtf8Safe(const std::string_view & text, int & offset) {
        U8_BACK_1(((uint8_t *) text.data()), ((int32_t) 0), offset);
    }


    static bool isValid(char32_t c) {
        return c < 0x10FFFF; // Maximum Unicode code point value.
    }


    static char32_t toUpper(char32_t c) {
        return (char32_t) u_toupper((UChar32) c);
    }

    static char32_t toLower(char32_t c) {
        return (char32_t) u_tolower((UChar32) c);
    }

    static void setUtf8AndAdvanceOffset(std::string & destination, int & offset, char32_t c) {
        auto newUChar = (UChar32) c;
        U8_APPEND_UNSAFE(&destination[0], offset, newUChar); // NOLINT
    }
};

} // namespace Balau

#endif // COM_BORA_SOFTWARE__BALAU_TYPE__CHARACTER