string.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_TEXT_STRING_H_
#define GENESIS_UTILS_TEXT_STRING_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2024 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 <lucas.czech@sund.ku.dk>
    University of Copenhagen, Globe Institute, Section for GeoGenetics
    Oster Voldgade 5-7, 1350 Copenhagen K, Denmark
*/
 
#include "genesis/utils/text/char.hpp"
 
#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Compare and Find
// =================================================================================================
 
bool contains_ci( std::vector<std::string> const& haystack, std::string const& needle );
 
bool contains_ci_alnum( std::vector<std::string> const& haystack, std::string const& needle );
 
int strcasecmp( char const* s1, char const* s2 );
 
int strncasecmp( char const* s1, char const* s2, size_t n );
 
bool equals_ci( std::string const& lhs, std::string const& rhs );
 
bool equals_ci_alnum( std::string const& lhs, std::string const& rhs );
 
bool starts_with( std::string const& text, std::string const& prefix );
 
bool starts_with( std::string const& text, std::string const& prefix, std::string& suffix );
 
bool starts_with_ci( std::string const& text, std::string const& prefix );
 
bool starts_with_ci( std::string const& text, std::string const& prefix, std::string& suffix );
 
bool starts_with_ci_alnum( std::string const& text, std::string const& prefix );
 
bool starts_with_ci_alnum(
    std::string const& text,
    std::string const& prefix,
    std::string& suffix,
    bool trim_suffix = false
);
 
bool ends_with( std::string const& text, std::string const& suffix );
 
bool ends_with( std::string const& text, std::string const& suffix, std::string& prefix );
 
bool ends_with_ci( std::string const& text, std::string const& suffix );
 
bool ends_with_ci( std::string const& text, std::string const& suffix, std::string& prefix );
 
bool ends_with_ci_alnum( std::string const& text, std::string const& suffix );
 
bool ends_with_ci_alnum(
    std::string const& text,
    std::string const& suffix,
    std::string& prefix,
    bool trim_prefix = false
);
 
bool match_wildcards( std::string const& str, std::string const& pattern );
 
int compare_natural( std::string const& lhs, std::string const& rhs );
 
template <class T = std::string>
struct NaturalLess {
    bool operator()( T const& lhs, T const& rhs ) const {
        return compare_natural( lhs, rhs ) < 0;
    }
};
 
template <class T = std::string>
struct NaturalGreater {
    bool operator()( T const& lhs, T const& rhs ) const {
        return compare_natural( lhs, rhs ) > 0;
    }
};
 
template <typename RandomAccessIterator>
inline void sort_natural(
    RandomAccessIterator first,
    RandomAccessIterator last,
    bool reverse = false
) {
    // The above implementations of NaturalLess and NaturalGreater were using std::binary_function
    // before, which is deprecated. We hence now simply removed those, which seems to work.
    // If that causes trouble with other compilers, see https://stackoverflow.com/a/33115341 for
    // alternative solutions.
 
    using T = typename RandomAccessIterator::value_type;
    if( reverse ) {
        std::sort( first, last, NaturalGreater<T>() );
    } else {
        std::sort( first, last, NaturalLess<T>() );
    }
}
 
// =================================================================================================
//     Substrings
// =================================================================================================
 
std::string head( std::string const& text, size_t lines = 10 );
 
std::string tail( std::string const& text, size_t lines = 10 );
 
// =================================================================================================
//     Split and Count
// =================================================================================================
 
size_t count_substring_occurrences( std::string const& str, std::string const& sub );
 
std::vector<std::string> split (
    std::string const& str,
    char delimiter = '\t',
    const bool trim_empty = true
);
 
std::vector<std::string> split (
    std::string const& str,
    std::string const& delimiters,
    const bool trim_empty = true
);
 
std::vector<std::string> split (
    std::string const& str,
    std::function<bool (char)> delimiter_predicate,
    const bool trim_empty = true
);
 
std::vector<std::string> split_at (
    std::string const& str,
    std::string const& delimiter,
    const bool trim_empty = true
);
 
std::vector<size_t> split_range_list( std::string const& str );
 
// =================================================================================================
//     Manipulate
// =================================================================================================
 
std::string wrap(
    std::string const& text,
    size_t line_length = 80
);
 
std::string indent(
    std::string const& text,
    std::string const& indentation = "    "
);
 
std::string replace_all(
    std::string const& text,
    std::string const& search,
    std::string const& replace
);
 
std::string remove_all(
    std::string const& text,
    std::string const& search
);
 
std::string replace_all_chars(
    std::string const& text,
    std::string const& search_chars,
    char               replace
);
 
template< class UnaryPredicate >
std::string replace_all_chars_pred(
    std::string const& text,
    UnaryPredicate     predicate,
    char               replace
) {
    auto result = text;
    for( auto& c : result ) {
        if( predicate( c ) ) {
            c = replace;
        }
    }
    return result;
}
 
std::string remove_all_chars(
    std::string const& text,
    std::string const& search_chars
);
 
template< class UnaryPredicate >
std::string remove_all_chars_pred(
    std::string const& text,
    UnaryPredicate     predicate
) {
    auto result = text;
    result.erase( std::remove_if( result.begin(), result.end(), predicate ), result.end() );
    return result;
}
 
std::string remove_all_non_alnum( std::string const& text );
 
std::string trim_right (
    std::string const& s,
    std::string const& delimiters = " \f\n\r\t\v"
);
 
std::string trim_left (
    std::string const& s,
    std::string const& delimiters = " \f\n\r\t\v"
);
 
std::string trim (
    std::string const& s,
    std::string const& delimiters = " \f\n\r\t\v"
);
 
// =================================================================================================
//     Case Conversion
// =================================================================================================
 
inline std::string to_lower( std::string const& str )
{
    auto res = str;
    for( auto& c : res ){
        // Weird C relicts need weird conversions...
        // See https://en.cppreference.com/w/cpp/string/byte/tolower
        c = static_cast<char>( std::tolower( static_cast<unsigned char>( c )));
    }
    return res;
}
 
inline void to_lower_inplace( std::string& str )
{
    for( auto& c : str ){
        c = static_cast<char>( std::tolower( static_cast<unsigned char>( c )));
    }
}
 
inline std::string to_upper( std::string const& str )
{
    auto res = str;
    for( auto& c : res ){
        c = static_cast<char>( std::toupper( static_cast<unsigned char>( c )));
    }
    return res;
}
 
inline void to_upper_inplace( std::string& str )
{
    for( auto& c : str ){
        c = static_cast<char>( std::toupper( static_cast<unsigned char>( c )));
    }
}
 
void to_lower_ascii_inplace( std::string& str );
 
std::string to_lower_ascii( std::string const& str );
 
void to_upper_ascii_inplace( std::string& str );
 
std::string to_upper_ascii( std::string const& str );
 
// =================================================================================================
//     Normalize
// =================================================================================================
 
std::string escape( std::string const& text );
 
std::string deescape( std::string const& text );
 
char deescape( char c );
 
// =================================================================================================
//     Output
// =================================================================================================
 
std::string repeat( std::string const& word, size_t times );
 
std::string to_string_leading_zeros( size_t value, size_t length = 6 );
 
std::string to_string_precise( double value, int precision = 6 );
 
std::string to_string_rounded( double value, int precision = 6 );
 
template <typename T>
std::string to_string_nice( T const& v )
{
    std::ostringstream s;
    s << v;
    return s.str();
}
 
std::string to_string_byte_format( size_t value );
 
template<typename T>
inline std::string to_bit_string(
    T const x, char const zero = '0', char const one = '1', bool const byte_space = true
) {
    static_assert(
        std::is_unsigned<T>::value,
        "Can only use to_bit_string() with unsigned types."
    );
 
    std::string binary = "";
    T mask = 1;
    for( size_t i = 0; i < sizeof(T) * 8; ++i ) {
        if( byte_space && i > 0 && i % 8 == 0 ) {
            binary = ' ' + binary;
        }
        if( mask & x ) {
            binary = one + binary;
        } else {
            binary = zero + binary;
        }
        mask <<= 1;
    }
    return binary;
}
 
template <
    typename C,
    typename std::enable_if<
        ! std::is_same<typename C::value_type, unsigned char>::value &&
        ! std::is_same<typename C::value_type,   signed char>::value
    >::type* = nullptr
>
std::ostream& join( std::ostream& stream, C const& container, std::string const& delimiter = ", " )
{
    for( auto const& element : container ) {
        if( &element != &(*container.begin()) ) {
            stream << delimiter;
        }
        stream << element;
    }
    return stream;
}
 
template <
    typename C,
    typename std::enable_if<
        std::is_same<typename C::value_type, unsigned char>::value ||
        std::is_same<typename C::value_type,   signed char>::value
    >::type* = nullptr
>
std::ostream& join( std::ostream& stream, C const& container, std::string const& delimiter = ", " )
{
    for( auto const& element : container ) {
        if( &element != &(*container.begin()) ) {
            stream << delimiter;
        }
        stream << static_cast<int>( element );
    }
    return stream;
}
 
template <typename C>
std::string join( C const& container, std::string const& delimiter = ", " )
{
    std::ostringstream s;
    join( s, container, delimiter );
    return s.str();
}
 
} // namespace utils
} // namespace genesis
 
#endif // include guard