char.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_TEXT_CHAR_H_
#define GENESIS_UTILS_TEXT_CHAR_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2022 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include <cctype>
#include <climits>
#include <string>
#include <type_traits>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     ASCII Char Functions
// =================================================================================================
 
template <typename T>
constexpr bool is_ascii(std::true_type /* signed */, T c) noexcept
{
    // All positive values are valid ASCII codes
    return c >= 0;
}
 
template <typename T>
constexpr bool is_ascii(std::false_type /* unsigned */, T c) noexcept
{
    // All values less than or equal to 0x7F (DEL) are valid ASCII codes
    return c <= 0x7F;
}
 
constexpr bool is_ascii(char c) noexcept
{
    static_assert(0x7F <= CHAR_MAX, "The compiler is not using ASCII. We cannot work like that!");
    return is_ascii(std::is_signed<char>{}, c);
}
 
constexpr bool is_cntrl(char c) noexcept
{
    return c == 0x7F || (c >= 0 && c <= 0x1F);
}
 
constexpr bool is_control(char c) noexcept
{
    return (c >= 0x00 && c <= 0x08) || (c >= 0x0E && c <= 0x1F) || c == 0x7F;
}
 
constexpr bool is_digit(char c) noexcept
{
    static_assert('0' == 48,      "The compiler is not using ASCII. We cannot work like that!");
    static_assert('0' + 9 == '9', "The compiler is not using ASCII. We cannot work like that!");
    return c >= '0' && c <= '9';
}
 
constexpr bool is_xdigit(char c) noexcept
{
    static_assert('A' + 5 == 'F', "The compiler is not using ASCII. We cannot work like that!");
    static_assert('a' + 5 == 'f', "The compiler is not using ASCII. We cannot work like that!");
    return is_digit(c) || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
}
 
constexpr bool is_lower(char c) noexcept
{
    static_assert('a' == 97,       "The compiler is not using ASCII. We cannot work like that!");
    static_assert('a' + 25 == 'z', "The compiler is not using ASCII. We cannot work like that!");
    return c >= 'a' && c <= 'z';
}
 
constexpr bool is_upper(char c) noexcept
{
    static_assert('A' == 65,       "The compiler is not using ASCII. We cannot work like that!");
    static_assert('A' + 25 == 'Z', "The compiler is not using ASCII. We cannot work like that!");
    return c >= 'A' && c <= 'Z';
}
 
constexpr bool is_alpha(char c) noexcept
{
    return is_lower(c) || is_upper(c);
}
 
constexpr bool is_alnum(char c) noexcept
{
    return is_alpha(c) || is_digit(c);
}
 
constexpr bool is_punct(char c) noexcept
{
    static_assert('!' + 1 == '"',  "The compiler is not using ASCII. We cannot work like that!");
    static_assert(':' + 1 == ';',  "The compiler is not using ASCII. We cannot work like that!");
    static_assert('[' + 1 == '\\', "The compiler is not using ASCII. We cannot work like that!");
    static_assert('{' + 1 == '|',  "The compiler is not using ASCII. We cannot work like that!");
 
    return (c >= '!' && c <= '/') || (c >= ':' && c <= '@') || (c >= '[' && c <= '`') || (c >= '{' && c <= '~');
}
 
constexpr bool is_graph(char c) noexcept
{
    return c >= '!' && c <='~';
}
 
constexpr bool is_blank(char c) noexcept
{
    return c == '\t' || c == ' ';
}
 
constexpr bool is_newline(char c) noexcept
{
    return c == '\n' || c == '\r';
}
 
constexpr bool is_other_space(char c) noexcept
{
    return c == '\f' || c == '\v';
}
 
constexpr bool is_space(char c) noexcept
{
    return is_blank(c) || is_newline(c) || is_other_space(c);
}
 
constexpr bool is_print(char c) noexcept
{
    return c >= ' ' && c <= '~';
}
 
// =================================================================================================
//     Conversion Functions
// =================================================================================================
 
constexpr char to_lower(char c) noexcept
{
    static_assert('z' - 'Z' == 0x20,  "The compiler is not using ASCII. We cannot work like that!");
    return ( 'A' <= c && c <= 'Z' ) ? c + 0x20 : c;
}
 
constexpr char to_upper(char c) noexcept
{
    static_assert('z' - 'Z' == 0x20,  "The compiler is not using ASCII. We cannot work like that!");
    return ( 'a' <= c && c <= 'z' ) ? c - 0x20 : c;
}
 
// =================================================================================================
//     Chars Helper Functions
// =================================================================================================
 
constexpr bool char_match_ci( char c1,  char c2 ) noexcept
{
    return to_lower( c1 ) == to_lower( c2 );
    // Locale aware version, not used any more:
    // return std::tolower( static_cast<unsigned char>( c1 )) == std::tolower( static_cast<unsigned char>( c2 ));
}
 
std::string char_to_hex( char c, bool full = true );
 
std::string char_to_hex( unsigned char c, bool full = true );
 
} // namespace utils
} // namespace genesis
 
#endif // include guard