gempyre_utils.h

Go to the documentation of this file.

#ifndef UTILS_H
#define UTILS_H
 
#include <ctime>
#include <chrono>
#include <vector>
#include <map>
#include <sstream>
#include <fstream>
#include <optional>
#include <variant>
#include <functional>
#include <algorithm>
#include <future>
#include <limits>
#include <iomanip>
#include <any>
#include <string_view>
 
#define GEMPYREUTILSDEBUG(x) GempyreUtils::log(Utils::LogLevel::Debug, x, __FILE__, __LINE__)
#define gempyre_utils_assert(b) (b || GempyreUtils::do_fatal("Panic!", nullptr, __FILE__, __LINE__))
#define gempyre_utils_assert_x(b, x) (b || GempyreUtils::do_fatal(x, nullptr, __FILE__, __LINE__))
#define gempyre_utils_assert_x_f(b, x, f) (b || GempyreUtils::do_fatal(x, f, __FILE__, __LINE__))
#define gempyre_utils_fatal(x) GempyreUtils::do_fatal(x, nullptr, __FILE__, __LINE__)
#define gempyre_utils_fatal_f(x, f) GempyreUtils::do_fatal(x, f, __FILE__, __LINE__)
#define gempyre_utils_auto_clean(p, f) std::unique_ptr<std::remove_pointer<decltype(p)>::type, decltype(&f)> _ ## p (p, &f)
#define gempyre_utils_auto_close(p, f) GempyreUtils::_Close<std::decay_t<decltype(p)>, decltype(&f)> _ ## p (p, &f)
 
 
#ifdef WINDOWS_EXPORT
    #define UTILS_EX __declspec(dllexport)
#else
    #define UTILS_EX
#endif
 
#ifdef _MSC_VER
using SSIZE_T = long long;
#else
using SSIZE_T = ssize_t;
#endif
 
 
 
namespace GempyreUtils {
enum class LogLevel : int {
    None,       
    Fatal,      
    Error,      
    Warning,    
    Info,       
    Debug,      
    Debug_Trace 
    };
 
class LogWriter {
public:
    LogWriter();
    virtual ~LogWriter(); 
    LogWriter(const GempyreUtils::LogWriter&) = delete;
    LogWriter& operator=(const GempyreUtils::LogWriter&) = delete; 
    virtual std::string header(LogLevel logLevel);
 
    virtual bool do_write(const char* buffer, size_t count) = 0;
    virtual bool has_ansi() const;
private:
    LogWriter* m_previousLogWriter{nullptr};
};
 
class UTILS_EX FileLogWriter : public LogWriter {
public:
    FileLogWriter(std::string_view path);
protected:
    bool do_write(const char* buffer, size_t count) override;
protected:
    std::ofstream m_file;
};
 
class UTILS_EX StreamLogWriter : public LogWriter {
public:
    StreamLogWriter(std::ostream& os);
protected:
    bool do_write(const char* buffer, size_t count) override;
protected:
    std::ostream& m_os;
};
 
UTILS_EX void set_log_level(LogLevel level);
 
UTILS_EX LogLevel log_level(); 
 
UTILS_EX std::string to_str(LogLevel log_level);
 
UTILS_EX std::ostream log_stream(LogLevel logLevel);
 
template <typename T, typename ...Args>
inline void log_line(LogLevel level, std::ostream& os, const T& e, Args... args) {
    os << e << " ";
    log_line(level, os, args...);
}
 
 
UTILS_EX void process_exit(int);
 
template<typename T>
inline void log_line(LogLevel level, std::ostream& os, const T& e) {
    os << e << std::endl;
    if(level == LogLevel::Fatal)  {
        process_exit(99);
    }
}
 
template <typename T, typename ...Args>
inline void log(LogLevel level, const T& e, Args... args) {
    if(level <= log_level()) {
        auto os = log_stream(level);
        log_line(level, os, e, args...);
    }
}
 
template <LogLevel level, typename T, typename ...Args>
inline void write_log(const T& e, Args... args) {
    log(level, e, args...);
}
 
template <typename T, typename ...Args>
inline void log_debug(const T& e, Args... args) {
    write_log<LogLevel::Debug, T, Args...>(e, args...);
}
 
 
inline bool do_fatal(std::string_view txt, std::function<void()> f, const char* file, int line) {
    if(f) f();
    log(LogLevel::Fatal, txt, "at", file, "line:", line);
    return false;
}
 
 
#ifdef _MSC_VER
#define __PRETTY_FUNCTION__ __FUNCSIG__
#endif
 
#define GEM_DEBUG(...) GempyreUtils::log(GempyreUtils::LogLevel::Debug, __PRETTY_FUNCTION__, __VA_ARGS__)
}
 
 
 
 
namespace GempyreUtils {
 
//Helper for C memory management
template <typename T, typename A>
class _Close {
public:
    _Close(T ref, A&& f) : t(ref), d(f) {}
    ~_Close() {(void) this->d(this->t);}
    _Close(_Close&& other) = default;
    _Close& operator=(_Close&& other) = default;
    _Close(const _Close& other) = delete;
    _Close& operator=(const _Close& other) = delete;
private:
    T t;
    A d;
};
 
 
UTILS_EX void init();
UTILS_EX std::string current_time_string();
UTILS_EX std::string last_error();
 
template<typename E>
struct ErrorValue {
    ErrorValue(E&& e) : err{e} {}
    ErrorValue(const E& e) : err{e} {}
    E err;
    };
 
// internal for Result
template <typename E> struct Error {
    using value_type = E;
    E error;
};
template <typename R, typename E = std::string>
struct Result : private std::variant<R, Error<E>> {
    using Err = Error<E>;
    using value_type = R;
    using error_type = E;  
    constexpr Result(R&& r) : std::variant<R, Err>{r} {}
    constexpr Result(Err&& e) : std::variant<R, Err>{e} {} // use makeError
    constexpr Result(const R& r) : std::variant<R, Err>{r} {}
    constexpr Result(const Err& e) : std::variant<R,Err>{e} {}
    constexpr Result& operator=(R&& r) {*this = std::move(r); return *this;}
    constexpr Result& operator=(Err&& e) {*this = std::move(e); return *this;}
    constexpr Result& operator=(const R& r) {*this = r; return *this;}
    constexpr Result& operator=(const Err &e) {*this = e; return *this;}
    constexpr operator bool() const {return std::get_if<R>(this);}
    constexpr operator std::optional<R>() const {return has_value() ? std::make_optional<R>(value()) : std::nullopt;}
    constexpr bool has_value() const {return operator bool();} 
    constexpr const R& value() const {return std::get<R>(*this);}
    constexpr const E& error() const {return std::get<Err>(*this).error;}
    constexpr R& value() {return std::get<R>(*this);}
    constexpr R& operator *() {return std::get<R>(*this);}
    constexpr const R& operator *() const {return std::get<R>(*this);}
    constexpr R* operator ->() {return &std::get<R>(*this);}
    constexpr const R* operator ->() const {return &std::get<R>(*this);}
    constexpr static auto make_error(const E& e) {return Result<R, E>{Error<E>{e}};}
    constexpr static auto make_error(E&& e) {return Result<R, E>{Error<E>{e}};}
    constexpr static auto make_error() {return Result<R, E>{Error<E>{}};}   
    constexpr static auto ok() {return Result<R, E>{R{}};}                 
};
 
template <typename R, typename E>
constexpr inline bool operator==(const Result<R, E>& a, const Result<R, E>& b) {return Result<R, E>::ParentType::operator==(a, b);}
template <typename R, typename E>
constexpr inline bool operator!=(const Result<R, E>& a, const Result<R, E>& b) {return !operator==(a, b);}
 
using ResultTrue = Result<std::true_type, std::string>;
 
template<typename T, typename... A>
Result<T, std::string> make_error(A&&... a) {
    std::stringstream str;
    (str << ... << a); //str << ... << a;
    return Result<T, std::string>::make_error(str.str());
}
 
UTILS_EX std::string qq(std::string_view s);
 
UTILS_EX std::string chop(std::string_view s);
 
UTILS_EX std::string chop(std::string_view s, std::string_view chopped);
 
UTILS_EX std::string substitute(std::string_view str, std::string_view substring,  std::string_view substitution);
 
UTILS_EX std::string remove_spaces(std::string_view str);
 
template <typename T>
T convert(std::string_view source) {
    std::istringstream ss(std::string{source});
    typename std::remove_const<T>::type v{};
    ss.operator>>(v); //overloads have similar conversions MSVC19
    return v;
}
 
inline
std::string_view right(std::string_view str, size_t p) {
    return str.substr(str.length() - p);
}
 
template <>
inline std::string convert<std::string>(std::string_view source)
{
    return std::string{source};
}
 
template <typename T>
std::optional<T> parse(std::string_view source, const std::optional<int>& forced_base = std::nullopt) {
    if (source.empty())
        return std::nullopt;    
    std::stringstream ss;
    if (forced_base) {
        ss << std::setbase(*forced_base) << source;
    } else {
        auto base = std::dec;
        if (source.size() > 1 && source[0] == '0') {
            if (source.size() > 2 && (source[1] == 'x' || source[1] == 'X')) {
                base = std::hex;
            } else {
                base = std::oct;
            }
        }
        ss << base << source;
    }
    T v;
    /*static_cast<std::istream&>(ss)*/ 
    ss >> v;   //MSVC said it would be otherwise ambiguous
    return !ss.fail() && (!forced_base || ss.eof()) ? std::make_optional(v) : std::nullopt;
}
 
template <class T>
std::string to_low(const T& str) {
    std::string n;
    std::transform(std::begin(str), std::end(str), std::back_inserter(n),
                                    [](auto c){return std::tolower(c);});
    return n;
}
 
 
template <class T>
std::string to_upper(const T& str) {
    std::string n;
    std::transform(std::begin(str), std::end(str), std::back_inserter(n),
                                    [](auto c){return std::toupper(c);});
    return n;
}
 
 
inline std::string_view ltrim(std::string_view str) {
    const auto begin = std::find_if(str.begin(), str.end(), [](auto ch) {
        return (ch > ' ');
    });
   return str.substr(static_cast<std::string_view::size_type>(
    std::distance(str.begin(), begin)));
}
 
inline std::string_view rtrim(std::string_view str) {
    const auto end = std::find_if(str.rbegin(), str.rend(), [](auto ch) {
        return (ch > ' ');
    });
    return str.substr(0, static_cast<std::string_view::size_type>(
        std::distance(end, str.rend())));
}
 
inline std::string_view trim(std::string_view str) {
    return ltrim(rtrim(str));
}
 
 
 
 template< typename T >
 std::string to_hex(T ival) {
   std::stringstream stream;
   stream << std::setfill('0') << std::setw(sizeof(T) * 2)
          << std::hex << ival;
   return stream.str();
 }
 
 
UTILS_EX int levenshtein_distance(std::string_view s1, std::string_view s2);
 
UTILS_EX bool is_valid_utf8(std::string_view str); 
 
inline bool iequals(std::string_view a, std::string_view b) {
    return 
        std::equal(std::begin(a), std::end(a), std::begin(b), std::end(b), [](auto a, auto b) {
        return std::tolower(a) == std::tolower(b);
    });
}
 
template<typename C, typename T>
std::optional<T> at(const C& container, std::string_view s, unsigned index = 0) {
    const auto range = container.equal_range(s);
    const auto it = std::next(range.first, index);
    return (std::distance(range.first, it) < std::distance(range.first, range.second)) ?
                std::make_optional(it->second) : std::nullopt;
}
 
template<typename C, typename T>
T at_or(const C& container, std::string_view s, const T& defaultValue, unsigned index = 0) {
    const auto v = at<C, T>(container, s, index);
    return v.has_value() ? *v : defaultValue;
}
 
template <class Container = std::vector<std::string>>
Container split(std::string_view str, const char splitChar = ' ') {
    Container con;
    std::istringstream iss(std::string{str});
    for(std::string token; iss.good() && std::getline(iss, token, splitChar);) {
        con.insert(con.end(), convert<typename Container::value_type>(token));
    }
    return con;
}
 
template <typename IT>
inline constexpr std::string_view make_string_view(IT begin, IT end)
{
    return   (begin == end) ? std::string_view{nullptr} : std::string_view{&*begin, std::distance(begin, end)};
}
 
template <class T, typename K = typename T::key_type>
std::vector<K> keys(const T& map) {
    std::vector<K> ks; ks.resize(map.size());
    std::transform(map.begin(), map.end(), ks.begin(), [](const auto& p) {return p.first;});
    return ks;
}
 
    template<typename V>
    struct DefaultJoiner {
        auto operator()(const V& v) const {return v;}
    };
 
template <class IT, typename In, typename Out>
[[deprecated("See join with Callable")]] std::string join(const IT& begin,
                 const IT& end,
                 std::string_view joinChar = "",
                 const std::function<Out (const In&)>& f = [](const In& k)->Out{return k;}) {
    std::string s;
    std::ostringstream iss(s);
    if(begin != end) {
        for(auto it = begin;;) {
            iss << f(*it);
            if(!(++it != end)) break;
            if(!joinChar.empty())
                iss << joinChar;
        }
    }
    return iss.str();
}
 
template <class T, typename In, typename Out>
[[deprecated("See join with Callable")]] std::string join(const T& t,
                 std::string_view joinChar = "",
                 const std::function<Out (const In&)>& f = [](const In& v)->Out{return v;}) {
    return join(t.begin(), t.end(), joinChar, f);
}
 
template <class IT, typename In, typename Out, typename = std::enable_if_t<std::is_pointer<IT>::value>>
[[deprecated("See join with Callable")]] std::string join(const IT begin,
                 const IT end,
                 std::string_view joinChar = "",
                 const std::function<Out (const In&)>& f = [](const In& k)->Out{return k;}) {
    std::string s;
    std::ostringstream iss(s);
    if(begin != end) {
        for(auto it = begin;;) {
            iss << f(*it);
            if(!(++it != end)) break;
            if(!joinChar.empty())
                iss << joinChar;
        }
    }
    return iss.str();
}
 
 
template <typename IT, typename Callable = DefaultJoiner<typename IT::value_type>, 
    typename = std::enable_if_t<!std::is_pointer<IT>::value>>
std::string join(const IT& begin,
                 const IT& end,
                 std::string_view joinChar = "",
                 const Callable& f = Callable{}) {
    std::string s;
    std::ostringstream iss(s);
    if(begin != end) {
        for(auto it = begin;;) {
            iss << f(*it);
            if(!(++it != end)) break;
            if(!joinChar.empty())
                iss << joinChar;
        }
    }
    return iss.str();
}
 
template <typename IT, typename Callable = DefaultJoiner<typename std::remove_pointer<IT>::type>,
          typename = std::enable_if_t<std::is_pointer<IT>::value>>
std::string join(const IT begin,
                 const IT end,
                 std::string_view joinChar = "",
                 const Callable& f = Callable{}) {
    std::string s;
    std::ostringstream iss(s);
    if(begin != end) {
        for(auto it = begin;;) {
            iss << f(*it);
            if(!(++it != end)) break;
            if(!joinChar.empty())
                iss << joinChar;
        }
    }
    return iss.str();
}
 
template <typename T, typename Callable = DefaultJoiner<typename T::value_type>>
std::string join(const T& t,
                 std::string_view joinChar = "",
                 const Callable& f = Callable{}) {
    return join(std::begin(t), std::end(t), joinChar, f);
}
 
template <typename T>
T merge(const T& b1, const T& b2) {
       T bytes(b1.size() + b2.size());
       auto begin = bytes.begin();
       std::copy(b1.begin(), b1.end(), begin);
       std::advance(begin, std::distance(b1.begin(), b1.end()));
       std::copy(b2.begin(), b2.end(), begin);
       return bytes;
   }
 
// I just wonder why copy instead of move hence not public
template <typename T, typename ...Arg>
T merge(const T& b1, const T& b2, Arg ...args) {
    T bytes(b1.size() + b2.size());
    auto begin = bytes.begin();
    std::copy(b1.begin(), b1.end(), begin);
    std::advance(begin, std::distance(b1.begin(), b1.end()));
    std::copy(b2.begin(), b2.end(), begin);
    return merge(bytes, args...);
}
 
template <typename IT> IT advanced(IT it, int distance) {
    std::advance(it, distance);
    return it;
}
 
template <typename K, typename V >
std::optional<V> get_value(const std::multimap<K, V>& map, const K& key, int index = 0)
{
     const auto range = map.equal_range(key);
     return std::distance(range.first, range.second) > index ?
                 std::make_optional((advanced(range.first, index))->second) : std::nullopt;
}
 
 
 /*
 *  Misc Utils
 */
 
 
class expiror;
[[nodiscard]]
UTILS_EX std::shared_ptr<expiror> wait_expire(std::chrono::seconds s, const std::function<void ()>& onExpire);
class expiror {
public:
    ~expiror() {m_f.wait();}
private:
    expiror() = default;
    expiror(std::future<void>&& f) : m_f(std::move(f)) {}
    std::future<void> m_f{};
    friend std::shared_ptr<GempyreUtils::expiror> GempyreUtils::wait_expire(std::chrono::seconds s, const std::function<void ()>& onExpire);
};
 
 
UTILS_EX  std::string hexify(std::string_view src, std::string_view pat);
 
UTILS_EX  std::string unhexify(std::string_view src);
 
enum class OS {OtherOs, MacOs, WinOs, LinuxOs, AndroidOs, RaspberryOs};
 
UTILS_EX OS current_os();
 
UTILS_EX std::string html_file_launch_cmd();
 
 
enum  AddressType : unsigned {Ipv4 = 0x1, Ipv6 = 0x2};
UTILS_EX std::vector<std::string> ip_addresses(unsigned addressType);
 
 
enum class PathStyle {Native, Unix, Win};
 
UTILS_EX std::string get_link(std::string_view fname);
UTILS_EX bool is_dir(std::string_view fname);
UTILS_EX std::string working_dir();
UTILS_EX std::string home_dir();
UTILS_EX std::string root_dir();
UTILS_EX std::string abs_path(std::string_view rpath);
UTILS_EX std::string path_pop(std::string_view filename, int steps = 1, PathStyle path_style = PathStyle::Native);
UTILS_EX std::vector<std::string> entries(std::string_view dirname);
 
[[deprecated("use entries")]]
inline std::vector<std::string> directory(std::string_view dirname) {return entries(dirname);}
 
UTILS_EX std::optional<std::string> read_process(std::string_view processName, const std::vector<std::string>& params);
UTILS_EX std::string base_name(std::string_view filename, PathStyle path_style = PathStyle::Native); 
UTILS_EX std::tuple<std::string, std::string> split_name(std::string_view filename, PathStyle path_style = PathStyle::Native);
UTILS_EX std::string temp_name();
UTILS_EX std::string host_name();
UTILS_EX std::optional<std::string> system_env(std::string_view env);
UTILS_EX bool is_hidden_entry(std::string_view filename);
UTILS_EX bool is_executable(std::string_view filename);
UTILS_EX SSIZE_T file_size(std::string_view filename);
UTILS_EX bool rename(std::string_view of, std::string_view nf);
UTILS_EX void remove_file(std::string_view filename);
UTILS_EX bool file_exists(std::string_view filename);
UTILS_EX std::optional<std::string> which(std::string_view filename);
UTILS_EX std::string push_path(std::string_view path, std::string_view name);
template<class ...NAME>
std::string push_path(std::string_view path, std::string_view name, NAME...names) {
    return push_path(push_path(path, name), names...);
}
 
UTILS_EX int execute(std::string_view prog, const std::vector<std::string_view>& parameters);
 
template<class ...PARAM>
UTILS_EX int execute(std::string_view prog, PARAM...parameters) {
    std::vector<std::string_view> parameter_list{parameters...};
    return execute(prog, parameter_list);
}
 
 
 
 
template <class T>
std::string write_to_temp(const T& data) {
    const auto name = GempyreUtils::temp_name();
    std::ofstream out(name, std::ios::out | std::ios::binary);
    std::ostreambuf_iterator<typename T::value_type> iter(out);
    std::copy(data.begin(), data.end(), iter);
    return name;
}
 
template <class T>
std::vector<T> slurp(std::string_view file, const size_t max = std::numeric_limits<size_t>::max()) {
   std::vector<T> vec;
   std::ifstream stream(std::string{file}, std::ios::in | std::ios::binary | std::ios::ate);
   if(!stream.is_open()) {
       log(LogLevel::Error, "Cannot open file", qq(file));
       return vec;
   }
   const auto size = std::min(max, static_cast<size_t>(stream.tellg()));
   if(size <= 0) {
       return vec;
   }
   vec.resize(size / sizeof (T), 0);
   stream.seekg(std::ios_base::beg);
   auto ptr = reinterpret_cast<char*>(vec.data());
   stream.read(ptr, static_cast<std::streamsize>(size));
   return vec;
 }
 
UTILS_EX std::string slurp(std::string_view file, const size_t max = std::numeric_limits<size_t>::max());
 
enum class JsonMode {Compact, Pretty};
//  or container type std::vector, std::unordered_map or std::map containing other values.
UTILS_EX Result<std::string> to_json_string(const std::any& any, JsonMode mode = JsonMode::Compact);
 
enum class MapType {Map, UnorderedMap};
UTILS_EX Result<std::any> json_to_any(std::string_view str, MapType map_type = MapType::UnorderedMap);
 
using JsonType = std::variant<
int,
double,
bool,
std::string,
std::nullptr_t,
std::vector<std::any>,
std::map<std::string, std::any>,
std::unordered_map<std::string, std::any>
>;
UTILS_EX ResultTrue set_json_value(std::any& any, std::string_view path, JsonType&& value);
 
UTILS_EX ResultTrue remove_json_value(std::any& any, std::string_view path);
 
UTILS_EX Result<JsonType> get_json_value(const std::any& any, std::string_view path);
 
UTILS_EX ResultTrue make_json_path(std::any& any, std::string_view path, 
    const std::function<JsonType (std::string_view, std::string_view)>& f = [](auto, auto name) {
        return (GempyreUtils::parse<int>(name)) ? 
        GempyreUtils::JsonType{std::vector<std::any>{}} : 
        GempyreUtils::JsonType{std::unordered_map<std::string, std::any>{}};});
 
UTILS_EX bool is_available(int port);
 
UTILS_EX std::string base64_encode(const unsigned char* bytes, size_t sz);
UTILS_EX std::string base64_encode(const std::vector<uint8_t> & vec);
UTILS_EX std::string base64_encode(std::string_view str);
UTILS_EX std::vector<uint8_t> base64_decode(std::string_view data);
 
 
enum class ArgType{
    NO_ARG, 
    REQ_ARG,    
    OPT_ARG 
    };
 
using ParamList = std::vector<std::string>;
 
using Options = std::multimap<std::string, std::string>;
 
using Params = std::tuple<ParamList, Options>;
 
UTILS_EX Params parse_args(int argc, char* argv[], const std::initializer_list<std::tuple<std::string, char, ArgType>>& args);
 
template <typename T>
T option_or(const Options& opts, std::string_view key, const T& default_value) {
    const auto it = opts.find(std::string{key});
    if(it == opts.end())
        return default_value;
    const auto parsed = parse<T>(it->second);
    return parsed ? parsed.value() : default_value;    
}
 
 
}
 
 
 
#endif // UTILS_H