generic.hpp

Go to the documentation of this file.

//====================================================
//     File data
//====================================================
//====================================================
//     Preprocessor settings
//====================================================
#pragma once
#ifndef OSMANIP_UTILITY_GENERIC_HPP
#define OSMANIP_UTILITY_GENERIC_HPP
 
//====================================================
//     Headers
//====================================================
 
// STD
#include <cmath>
#include <cstdlib>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace osm {
 
    //====================================================
    //     Constants
    //====================================================
    template <typename T>
    inline const T null_str = "";
 
    template <typename T>
    inline const T empty_space = " ";
 
    //====================================================
    //     Enum classes
    //====================================================
    enum class ANSI_SEARCH { first, generic };
 
    //====================================================
    //     Functions
    //====================================================
    extern std::vector<std::string> split_string(const std::string& input, const std::string& regex);
    extern std::string getCommandOut(const char* command);
 
    //====================================================
    //     except_error_func
    //====================================================
    template <typename T_err = std::runtime_error>
    inline T_err except_error_func(const std::string& beg = "", std::string var = nullptr,
                                   const std::string& end = "") {
        using namespace std::literals::string_literals;
 
        static std::ostringstream oss;
        oss.str("");
        oss.clear();
        oss << "\033[31m" << beg << " \""s
            << "\033[1m" << var << "\033[22m"
            << "\" "s << end << "\033[39m";
 
        return T_err(oss.str());
    }
 
    //====================================================
    //     is_escape
    //====================================================
    template <typename T>
    bool is_escape(const T& str, const ANSI_SEARCH& flag) {
        if constexpr (std::is_convertible_v<T, std::string_view> && !std::is_same_v<T, std::nullptr_t>) {
            switch (flag) {
                case (ANSI_SEARCH::first): {
                    return (std::string_view(str).length() < 7) && (str[0] == '\033');
                }
                case (ANSI_SEARCH::generic): {
                    return (std::string_view(str).find('\033') != std::string_view::npos);
                }
            }
        }
        return false;
    }
 
    //====================================================
    //     roundoff
    //====================================================
    template <typename T>
    inline T roundoff(T value, unsigned char prec) {
        T pow_10 = std::pow(10.0f, static_cast<T>(prec));
 
        return round(value * pow_10) / pow_10;
    }
 
    //====================================================
    //     isFloatingPoint
    //====================================================
    template <typename T>
    inline bool isFloatingPoint(const T&) {
        return std::is_floating_point<T>::value;
    }
 
    //====================================================
    //     one
    //====================================================
    template <typename T>
    inline T one(const T& iterating_var) {
        std::vector<T> counter_;
 
        if (isFloatingPoint(iterating_var)) {
            if (counter_.size() < 2) counter_.push_back(iterating_var);
            if (counter_.size() == 2) return abs(abs(counter_.front()) - abs(counter_.back()));
            return static_cast<T>(0);
        }
 
        counter_.clear();
        return 1;
    }
}  // namespace osm
 
//====================================================
//     std::string * int
//====================================================
inline std::string operator*(const std::string& generic_string, unsigned int integer) {
    std::string output;
    output.reserve(integer * generic_string.size());
 
    while (integer--) {
        output += generic_string;
    }
 
    return output;
}
 
#endif