StringUtils.hpp

Go to the documentation of this file.

// <CommandLineSimulator> -*- C++ -*-
 
 
#pragma once
 
#include <cinttypes>
#include <cstring>
#include <string>
#include <cstring>
#include <sstream>
#include <string>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <memory>
 
namespace sparta {
namespace utils {
 
//
inline std::string uint64_to_hexstr (uint64_t val)
{
    std::ostringstream oss;
    oss << std::hex << std::setw(8) << std::setfill('0') << (val >> 32)
        << "_" << std::setw(8) << (val & 0xffffffff);
    return oss.str();
}
 
 
 
//
inline std::string uint32_to_hexstr (uint32_t val)
{
    std::ostringstream oss;
    oss << std::hex << std::setw(8) << std::setfill('0') << val;
    return oss.str();
}
 
 
//
inline std::string uint64_to_str (uint64_t val)
{
    std::ostringstream ss;
    return (static_cast<std::ostringstream*>( &(ss << val))->str());
}
 
 
//
inline std::string uint32_to_str (uint32_t val)
{
    std::ostringstream ss;
    return (static_cast<std::ostringstream*>( &(ss << val))->str());
}
 
//
inline std::string int64_to_str (int64_t val)
{
    std::ostringstream ss;
    return (static_cast<std::ostringstream*>( &(ss << val))->str());
}
 
 
//
inline std::string int32_to_str (int32_t val)
{
    std::ostringstream ss;
    return (static_cast<std::ostringstream*>( &(ss << val))->str());
}
 
//
inline std::string bool_to_str (bool val)
{
    std::ostringstream ss;
    return (static_cast<std::ostringstream*>( &(ss << std::boolalpha << val))->str());
}
 
//
inline std::string bin_to_hexstr(const uint8_t *data, size_t size, const std::string &sep=" ")
{
    std::stringstream ss;
    ss << std::hex << std::setfill('0');
    for (size_t i = size; i > 0; --i) {
        ss << std::setw(2) << (uint32_t)data[i - 1];
        if (i - 1 != 0) {
            ss << sep;
        }
    }
    return ss.str();
}
 
//
inline std::string bin_to_bitstr(const uint8_t *data, size_t size, const std::string &sep=" ")
{
    std::stringstream ss;
 
    for (size_t i = size; i > 0; --i) {
        const auto byte = data[i - 1];
        for (size_t b = 8; b > 0; --b) {
            const auto mask = 1 << (b - 1);
 
            ss << ((byte & mask)  ? '1' : '0');
        }
        if (i > 1) {
            ss << sep;
        }
    }
 
    return ss.str();
}
 
//
inline std::string eliminate_whitespace(const std::string &str)
{
    std::string strip_str = str;
    strip_str.erase(std::remove_if(strip_str.begin(), strip_str.end(), ::isspace),
                    strip_str.end());
    return strip_str;
}   
 
//
inline std::string strip_whitespace(const std::string &str)
{
    const std::string STR_WHITESPACE = " \t\n\r";
 
    size_t start_pos = str.find_first_not_of(STR_WHITESPACE);
    size_t end_pos   = str.find_last_not_of(STR_WHITESPACE);
 
    return str.substr(start_pos, end_pos-start_pos + 1);
}   
 
//
inline std::string strip_string_pattern(const std::string & pat,
                                        const std::string & str)
{
    size_t start_pos = str.find(pat);
    if(start_pos == 0) {
        start_pos += pat.length();
    }
    else {
        start_pos = 0;
    }
 
    size_t end_pos = str.rfind(pat);
    if(end_pos == 0 || (end_pos + pat.length()) != str.length()) {
        end_pos = std::string::npos;
    }
    else {
        end_pos -= start_pos;
    }
 
    return str.substr(start_pos, end_pos);
}   
 
//
inline void tokenize(const std::string &in_str, std::vector<std::string> & str_vector, const std::string &delimiters = " ")
{
    size_t prev_pos = 0;
    size_t cur_pos = 0;
    while ((cur_pos = in_str.find_first_of(delimiters, prev_pos)) != std::string::npos) {
        str_vector.push_back(in_str.substr(prev_pos, cur_pos - prev_pos));
        prev_pos = cur_pos + 1;
    }
 
    str_vector.push_back(in_str.substr(prev_pos));
}   
 
//
//
//
//
//
//
//
inline void split_lines_around_tokens(std::istream & in_stream,
                                      std::vector<std::vector<std::string>> & str_vectors,
                                      const std::string & delimiters = " ",
                                      const char line_separator = '\n')
{
    std::string line;
    while (std::getline(in_stream, line, line_separator)) {
        str_vectors.emplace_back(std::vector<std::string>());
        tokenize(line, str_vectors.back(), delimiters);
    }
}   
 
 
//
inline void tokenize(const char *in_char_str, std::vector<std::string> & str_vector, const std::string &delimiters = " ")
{
    std::string in_str = in_char_str;
 
    tokenize(in_str, str_vector, delimiters);
}   
 
 
//
inline void tokenize_strip_whitespace(const std::string &in_str, std::vector<std::string> & str_vector, const std::string &delimiters = " ")
{
    size_t prev_pos = 0;
    size_t cur_pos = 0;
    while ((cur_pos = in_str.find_first_of(delimiters, prev_pos)) != std::string::npos) {
        str_vector.push_back(strip_whitespace(in_str.substr(prev_pos, cur_pos - prev_pos)));
        prev_pos = cur_pos + 1;
    }
 
    str_vector.push_back(strip_whitespace(in_str.substr(prev_pos)));
}   
 
 
//
inline void tokenize_strip_whitespace(const char *in_char_str, std::vector<std::string> & str_vector, const std::string &delimiters = " ")
{
    std::string in_str = in_char_str;
 
    tokenize_strip_whitespace(in_str, str_vector, delimiters);
}   
 
 
//
inline void tokenize_on_whitespace(const std::string &in_str, std::vector<std::string> & str_vector)
{
    const std::string DELIMITER = " \t\n\r";
 
    size_t prev_pos = 0;
    size_t cur_pos = 0;
    while ((cur_pos = in_str.find_first_of(DELIMITER, prev_pos)) != std::string::npos) {
        if (cur_pos != prev_pos) {
            str_vector.push_back(in_str.substr(prev_pos, cur_pos - prev_pos));
        }
        prev_pos = cur_pos + 1;
    }
 
    if (prev_pos != in_str.size()) {
        str_vector.push_back(in_str.substr(prev_pos));
    }
}   
 
 
//
inline void tokenize_on_whitespace(const char *in_char_str, std::vector<std::string> & str_vector)
{
    std::string in_str = in_char_str;
 
    tokenize_on_whitespace(in_str, str_vector);
}   
 
inline bool strcmp_with_null(const char *s1, const char *s2)
{
    if (s1 != nullptr && s2 != nullptr) {
        return !std::strcmp(s1, s2);
    }
    if (s1 == nullptr && s2 == nullptr) {
        return true;
    }
    return false;
}
 
//
//
//
inline uint32_t LevenshteinDistance(const char * s, size_t n,
                                    const char * t, size_t m)
{
    ++n;
    ++m;
    std::unique_ptr<size_t[]> dptr(new size_t[n * m]);
    size_t * d = dptr.get();
 
    memset(d, 0, sizeof(size_t) * n * m);
    for (size_t i = 1, im = 0; i < m; ++i, ++im) {
        for (size_t j = 1, jn = 0; j < n; ++j, ++jn) {
            if (s[jn] == t[im]) {
                d[(i * n) + j] = d[((i - 1) * n) + (j - 1)];
            } else {
                d[(i * n) + j] = std::min({
                    d[(i - 1) * n + j] + 1,          
                    d[(i - 1) * n + j] + 1,          
                    d[(i - 1) * n + (j - 1)] + 1     
                });
            }
        }
    }
 
    return d[n * m - 1];
}   
 
template <class AppliedTransform>
class TransformedString
{
public:
    TransformedString() = default;
 
    TransformedString(const char * str) :
        TransformedString(std::string(str))
    {}
 
    TransformedString(const std::string & str) :
        str_(str)
    {
        applyTransform_();
    }
 
    TransformedString & operator=(const std::string & str) {
        str_ = str;
        applyTransform_();
        return *this;
    }
 
    TransformedString(const TransformedString & rhs) :
        str_(rhs.str_)
    {}
 
    TransformedString & operator=(const TransformedString & rhs) {
        str_ = rhs.str_;
        return *this;
    }
 
    inline bool operator==(const TransformedString & rhs) const {
        return str_ == rhs.str_;
    }
 
    inline bool operator!=(const TransformedString & rhs) const {
        return str_ != rhs.str_;
    }
 
    inline bool operator==(const std::string & rhs) const {
        return str_ == rhs;
    }
 
    inline bool operator!=(const std::string & rhs) const {
        return str_ != rhs;
    }
 
    inline bool operator==(const char * rhs) const {
        return strcmp(str_.c_str(), rhs) == 0;
    }
 
    inline bool operator!=(const char * rhs) const {
        return strcmp(str_.c_str(), rhs) != 0;
    }
 
    inline const std::string & getString() const {
        return str_;
    }
 
    inline operator std::string() const {
        return str_;
    }
 
private:
    void applyTransform_() {
        std::transform(str_.begin(), str_.end(), str_.begin(), transformer_);
    }
 
    std::string str_;
    AppliedTransform transformer_;
};
 
struct make_lowercase {
    int operator()(const int ch) const {
        return std::tolower(ch);
    }
};
 
struct make_uppercase {
    int operator()(const int ch) const {
        return std::toupper(ch);
    }
};
 
typedef TransformedString<make_lowercase> lowercase_string;
 
typedef TransformedString<make_uppercase> UPPERCASE_STRING;
 
template <class AppliedTransform>
inline bool operator<(const TransformedString<AppliedTransform> & one,
                      const TransformedString<AppliedTransform> & two)
{
    return one.getString() < two.getString();
}
 
//
template <class AppliedTransform>
inline bool operator==(const std::string & one,
                       const TransformedString<AppliedTransform> & two)
{
    return one == two.getString();
}
 
template <class AppliedTransform>
inline bool operator!=(const std::string & one,
                       const TransformedString<AppliedTransform> & two)
{
    return one != two.getString();
}
 
}
}