string.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * 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, version 3.
 *
 * 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.
 */
#ifndef PLASK__STRING_H
#define PLASK__STRING_H
 
#include <string>
#include <tuple>
#include <vector>
 
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/tokenizer.hpp>
#include <boost/units/detail/utility.hpp>
 
#include <plask/config.hpp>   //for PLASK_API
 
namespace plask {
 
struct PLASK_API Printable {
 
    virtual void print(std::ostream& out) const = 0;
 
    virtual ~Printable();
 
    friend inline std::ostream& operator<<(std::ostream& out, const Printable& to_print) {
        to_print.print(out);
        return out;
    }
 
    std::string str() const;
};
 
template <typename Iter>
std::ostream& print_seq(std::ostream& out, Iter begin, Iter end, const char* sep = ", ") {
    if (begin == end) return out;
    out << str(*begin);
    while (++begin != end) { out << sep << str(*begin); }
    return out;
}
 
PLASK_API std::pair<std::string, std::string> splitString2(const std::string& to_split, char splitter);
 
template <typename Pred>
std::string filterChars(const std::string& str, Pred pred) {
    std::string result;
    for (auto c: str) if (pred(c)) result += c;
    return result;
}
 
template <typename CharReplacer>
std::string replaceChars(const std::string& str, CharReplacer repl) {
    std::string result;
    result.reserve(str.size());
    for (auto c: str) result += repl(c);
    return result;
}
 
PLASK_API std::string removedChars(const std::string& str, const std::string& chars_to_remove);
 
template<typename RangeT, typename PredicateT, typename SequenceSequenceT = std::vector<std::string> >
SequenceSequenceT splitAndTrimPred(RangeT & input, PredicateT pred, boost::algorithm::token_compress_mode_type eCompress = boost::algorithm::token_compress_off) {
    SequenceSequenceT result;
    boost::algorithm::split(result, input, pred, eCompress);
    for (auto& r: result) boost::algorithm::trim(r);
    return result;
}
 
typedef boost::tokenizer< boost::escaped_list_separator<char> > split_esc_tokenizer;
 
PLASK_API split_esc_tokenizer splitEscIterator(const std::string& str, char splitter, char quote_char = '\'', char esc_char = '\\');
 
PLASK_API std::vector<std::string> splitEsc(const std::string& str, char splitter, char quote_char = '\'', char esc_char = '\\');
 
PLASK_API bool isCid(const char* potential_id);
 
 
template <typename T>
std::string type_name() {
    std::string demangled = boost::units::detail::demangle(typeid(T).name());
    size_t s = demangled.rfind(':');
    if (s == std::string::npos) s = 0; else ++s;
    return demangled.substr(s, demangled.find('<')-s);
}
 
}       // namespace plask
 
#endif // STRING_H