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-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 "genesis/utils/text/char.hpp"
 
#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Compare
// =================================================================================================
 
bool contains_ci( std::vector<std::string> const& haystack, std::string const& needle );
 
bool equals_ci( std::string const& lhs, std::string const& rhs );
 
bool starts_with( std::string const & text, std::string const & start );
 
bool ends_with(   std::string const & text, std::string const & ending );
 
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 : public std::binary_function<T, T, bool> {
    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
) {
    using T = typename RandomAccessIterator::value_type;
    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 );
 
// =================================================================================================
//     Find and Count
// =================================================================================================
 
size_t count_substring_occurrences( std::string const& str, std::string const& sub );
 
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 replace_all_chars (
    std::string const& text,
    std::string const& search_chars,
    char               replace
);
 
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();
}
 
template <typename T>
std::string join( T const& v, std::string const& delimiter = ", " )
{
    std::ostringstream s;
    for( auto const& i : v ) {
        if( &i != &(*v.begin()) ) {
            s << delimiter;
        }
        s << i;
    }
    return s.str();
}
 
template <>
inline std::string join<std::vector<unsigned char>>(
    std::vector<unsigned char> const& v, std::string const& delimiter
) {
    std::ostringstream s;
    for( auto const& i : v ) {
        if( &i != &(*v.begin()) ) {
            s << delimiter;
        }
        s << static_cast<int>( i );
    }
    return s.str();
}
 
template<typename T>
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;
}
 
} // namespace utils
} // namespace genesis
 
#endif // include guard