conscience_util.h

Go to the documentation of this file.

#ifndef CONSCIENCE_UTIL_h
#define CONSCIENCE_UTIL_h
 
#include <chrono>
#include <iostream>
#include <iterator>
#include <map>
#include <any>
#include <array>
#include <memory>
#include <sstream>
#include <vector>
 
#include <algorithm>
#include <cassert>
#include <exception>
#include <functional>
#include <iomanip>
#include <iostream>
#include <optional>
#include <string>
#include <utility>
#include <variant>
 
#include <random>
 
// can't define those functions with inline because cause crash when nest the call of this function - so we define it with precompil macros
#define deleteIfNotNull(objPointer) \
    if (objPointer) {               \
        delete objPointer;          \
        objPointer = nullptr;       \
    }
#define deleteItems(vectorOfItems) [](const auto &theVector) { for (const auto * item : theVector) { delete item; } }(vectorOfItems)
#define deleteValues(mapOfKeysAndValues) [](const auto &theMap) { for (auto it = theMap.begin(); it != theMap.end(); it++) { delete it->second; } }(mapOfKeysAndValues)
#if DEBUG == 1
#define vectorSafeAt(vector, index, vectorDescription) [&](const auto *theVectorPtr, int theIndex) { return (theIndex >= theVectorPtr->size() ? throw std::runtime_error("WARNING: try to reach index " + to_string(theIndex) + " from vector " + vectorDescription + " of size " + to_string(theVectorPtr->size())) : theVectorPtr->at(theIndex)); }(vector, index)
#define mapSafeAt(map, key, mapDescription) [&](const auto *theMapPtr, const auto &theKey) { return (theMapPtr->find(theKey) == theMapPtr->end() ? throw std::runtime_error("WARNING: try to reach key " + toStringOrNullString(theKey) + " from map " + mapDescription + " of size " + to_string(theMapPtr->size())) : theMapPtr->at(theKey)); }(map, key)
#else
#define vectorSafeAt(vector, index, vectorDescription) (vector)->at(index)
#define mapSafeAt(map, key, mapDescription) (map)->at(key)
#endif
 
#define ASSERT(MSG, EXPR) \
    assert(((void)string((MSG)).c_str(), (EXPR)))
 
#define COMMA ,
#define MACRO_PARENS ()
 
// we need this helper to evaluate macro inside macro, e.g. for fields list, replace comma inside
#define VARGS_STR_HELPER(...) #__VA_ARGS__
#define VARGS_STR(...) VARGS_STR_HELPER(__VA_ARGS__)
 
// Rescan macro tokens 256 times
#define MACRO_EXPAND(arg) MACRO_EXPAND1(MACRO_EXPAND1(MACRO_EXPAND1(MACRO_EXPAND1(arg))))
#define MACRO_EXPAND1(arg) MACRO_EXPAND2(MACRO_EXPAND2(MACRO_EXPAND2(MACRO_EXPAND2(arg))))
#define MACRO_EXPAND2(arg) MACRO_EXPAND3(MACRO_EXPAND3(MACRO_EXPAND3(MACRO_EXPAND3(arg))))
#define MACRO_EXPAND3(arg) MACRO_EXPAND4(MACRO_EXPAND4(MACRO_EXPAND4(MACRO_EXPAND4(arg))))
#define MACRO_EXPAND4(arg) arg
 
#define FOR_EACH(macro, ...) \
    __VA_OPT__(MACRO_EXPAND(FOR_EACH_HELPER(macro, __VA_ARGS__)))
#define FOR_EACH_HELPER(macro, a1, ...) \
    macro(a1)                           \
        __VA_OPT__(FOR_EACH_AGAIN MACRO_PARENS(macro, __VA_ARGS__))
#define FOR_EACH_AGAIN() FOR_EACH_HELPER
 
#define ENUM_TO_STRING_FILL_MAP(name)                              \
    {                                                              \
        /* if cppdoc added, we strip it */                         \
        std::string enumIdentifier = #name;                        \
        size_t pos = enumIdentifier.find("*/");                    \
        if (pos != std::string::npos) {                            \
            enumIdentifier = trim(enumIdentifier.substr(pos + 1)); \
        }                                                          \
        theMap[name] = enumIdentifier;                             \
    }
 
#define ENUM(ENUM_typeName, ...)                                                                            \
    enum ENUM_typeName : unsigned long long {                                                                         \
        __VA_ARGS__                                                                                         \
    };                                                                                                      \
    inline const std::map<ENUM_typeName, std::string> &getEnumNames##ENUM_typeName() {                      \
        static std::map<ENUM_typeName, std::string> theMap;                                                 \
        if (theMap.size() == 0) {                                                                           \
            FOR_EACH(ENUM_TO_STRING_FILL_MAP, __VA_ARGS__)                                                  \
        }                                                                                                   \
        return theMap;                                                                                      \
    }                                                                                                       \
    inline string toString##ENUM_typeName(ENUM_typeName enumElement) {                                      \
        auto &names = getEnumNames##ENUM_typeName();                                                        \
        auto matchIt = names.find(enumElement);                                                             \
        return matchIt == names.end() ? "unknown " + to_string(enumElement) : matchIt->second;              \
    }                                                                                                       \
    inline vector<ENUM_typeName> getValues##ENUM_typeName() {                                               \
        return {__VA_ARGS__};                                                                               \
    }                                                                                                       \
    inline bool is##ENUM_typeName##Valid(ENUM_typeName item) {                                              \
        vector<ENUM_typeName> values = getValues##ENUM_typeName();                                          \
        for (auto itemFromValues : values) {                                                                \
            if (itemFromValues == item) {                                                                   \
                return true;                                                                                \
            }                                                                                               \
        }                                                                                                   \
        return false;                                                                                       \
    }                                                                                                       \
    inline ENUM_typeName intTo##ENUM_typeName(int value) {                                                  \
        ENUM_typeName item = (ENUM_typeName)value;                                                          \
        if (!is##ENUM_typeName##Valid(item)) {                                                              \
            throw runtime_error("invalid " + string(#ENUM_typeName) + " value: " + to_string(value));       \
        }                                                                                                   \
        return item;                                                                                        \
    }                                                                                                       \
    inline ENUM_typeName parse##ENUM_typeName(const string &enumElementString) {                            \
        optional<ENUM_typeName> match = keyOfValueInMap(&getEnumNames##ENUM_typeName(), enumElementString); \
        if (match) {                                                                                        \
            return match.value();                                                                           \
        }                                                                                                   \
        throw conscience_utils::CannotParseEnumException("unknown element: " + enumElementString);          \
    }
 
using std::string, std::any, std::function, std::to_string, std::pair, std::make_pair, std::optional, std::vector, std::ostringstream, std::ostream_iterator, std::map, std::endl, std::cerr, std::variant, std::string, std::chrono::milliseconds, std::chrono::system_clock, std::chrono::high_resolution_clock, std::runtime_error, std::type_info;
 
namespace conscience_utils {
 
template <class TTestedType, class TPointee>
concept IsPointerOf = std::is_same_v<TTestedType, const TPointee *> || std::is_same_v<TTestedType, TPointee *> || std::is_same_v<TTestedType, std::shared_ptr<const TPointee>> || std::is_same_v<TTestedType, std::shared_ptr<TPointee>>;
 
template <class, template <class...> class>
inline constexpr bool IsTemplatedType = false;
 
template <template <class...> class T, class... Args>
inline constexpr bool IsTemplatedType<T<Args...>, T> = true;
 
template <typename T>
concept IsOptional = IsTemplatedType<T, std::optional>;
 
template <typename T>
concept IsVector = IsTemplatedType<T, std::vector>;
 
template <class A>
struct IsStdFixedArrayStruct : std::false_type {};
 
// only works with arrays by specialization.
template <class T, std::size_t I>
struct IsStdFixedArrayStruct<std::array<T, I>> : std::true_type {};
 
template <class T>
constexpr bool IsStdFixedArray = IsStdFixedArrayStruct<T>::value;
 
template <typename T>
concept IsMap = IsTemplatedType<T, std::map>;
 
template <typename T>
concept IsEnum = std::is_enum_v<T>;
 
// Le trait générique (cas "non-pointeur") :
template <typename T>
struct PointeeType {
    // Par défaut, "pas un pointeur" => pointee_type = void
    using pointee_type = void;
    static constexpr bool isPointer = false;
};
 
// Partiale specialization pour "U*"
template <typename U>
struct PointeeType<U *> {
    using pointee_type = U;
    static constexpr bool isPointer = true;
};
 
// Partiale specialization pour "const U*"
template <typename U>
struct PointeeType<const U *> {
    using pointee_type = const U;
    static constexpr bool isPointer = true;
};
 
// Partiale specialization pour "U* const"
template <typename U>
struct PointeeType<U *const> {
    using pointee_type = U;
    static constexpr bool isPointer = true;
};
 
// Partiale specialization pour "const U* const"
template <typename U>
struct PointeeType<const U *const> {
    using pointee_type = const U;
    static constexpr bool isPointer = true;
};
 
template <typename T>
concept IsStarPointer = PointeeType<std::remove_cvref_t<T>>::isPointer;
 
template <typename T>
struct SharedPtrTraits {
    static constexpr bool isSharedPtr = false;
    using pointee_type = void;
};
 
// Spécialisation partielle : T = std::shared_ptr<U>
template <typename U>
struct SharedPtrTraits<std::shared_ptr<U>> {
    static constexpr bool isSharedPtr = true;
    using pointee_type = U; // type contenu dans le shared_ptr
};
 
template <typename T>
concept IsSharedPointer = SharedPtrTraits<std::remove_cvref_t<T>>::isSharedPtr;
 
class CannotParseEnumException : public runtime_error {
public:
    CannotParseEnumException(const string &s) : runtime_error(s.c_str()) {}
};
 
static inline const string ALL_SPACES_STRING = " \n\t\r";
string trim(const string &str, const string &trimmedChars = " ");
 
string floatArrayToString(float *floatArray, int size);
 
string doubleArrayToString(double *floatArray, int size);
 
string intArrayToString(int *intArray, int size);
 
string boolToString(bool value);
 
string toStringCurrentTimeWithMillis();
 
string toStringDateAndTime();
 
vector<string> *splitString(const string &inputString, const string &delimiter, bool escapeDelimiterWithBackslash = false);
 
vector<float> *parseFloatList(string input, char separator = ',');
 
vector<int> *parseIntList(string input, char separator = ',');
 
map<string, string> parseMap(string input, const string &entriesSeparator = "&", const string &keyValueSeparator = "=", bool removeGlobalBracketIfExist = false);
 
optional<int> parseInt(const string &inputString);
optional<double> parseDouble(const string &inputString);
 
bool replaceInString(string &str, const string &from, const string &to, bool onlyFirst = true);
 
bool replaceAllInString(string &str, const string &from, const string &to);
 
void removeSpacesInString(string &str);
 
string toLowerCase(string &str);
string toUpperCase(string &str);
bool startsWithIgnoreCase(const string &str, const string &searchedPrefix);
void stringRemoveToken(string &s, const std::string_view &token);
 
string snakeCaseToPascalCase(const string &snakeCaseString);
 
template <class T>
string toStringOrNullString(T *object) {
    if (object == nullptr) {
        return "NULL";
    }
 
    ostringstream ss;
    ss << object;
    return ss.str();
}
 
template <class T>
string toStringOrNullString(T object) {
    ostringstream ss;
    ss << object;
    return ss.str();
}
 
template <class T>
string vectorToString(const vector<T> &vector, const char *separator = ",") {
    ostringstream oss;
 
    if (!vector.empty()) {
        // Convert all but the last element to avoid a trailing ","
        copy(vector.begin(), vector.end() - 1,
             ostream_iterator<T>(oss, separator));
 
        // Now add the last element with no delimiter
        oss << vector.back();
    }
 
    return oss.str();
}
 
template <class T>
vector<const T *> *vectorOfPointerToConst(vector<T *> *theVector) {
    return (vector<const T *> *)(vector<void *> *)theVector;
}
 
template <class T>
vector<const T *> &vectorOfPointerToConst(vector<T *> &&theVector) {
    return (vector<const T *> &)(vector<void *> &)theVector;
}
 
template <class T>
vector<const T *> &vectorOfPointerToConst(vector<T *> &theVector) {
    return (vector<const T *> &)(vector<void *> &)theVector;
}
 
template <class T>
const vector<const T *> &vectorOfPointerToConst(const vector<T *> &theVector) {
    return (const vector<const T *> &)(const vector<void *> &)theVector;
}
 
template <class T>
vector<T> vectorsConcat(const vector<T> &vector1, const vector<T> &vector2) {
    vector<T> copy = vector1;
    copy.insert(copy.end(), vector2.begin(), vector2.end());
    return copy;
}
 
template <class T>
vector<T *> *vectorCloneDeep(const vector<T *> *source) {
    if (source == nullptr) {
        return nullptr;
    }
    auto clone = new vector<T *>();
    for (T *item : *source) {
        clone->push_back(item->clone());
    }
    return clone;
}
 
template <class T>
inline void vectorPushIfMissing(vector<T> &vector, T value) {
    if (find(vector.begin(), vector.end(), value) == vector.end()) {
        vector.push_back(value);
    }
}
 
template <class T, class R>
inline vector<R> vectorTransform(const vector<T> &source, function<R(const T &item)> transformFunction) {
    vector<R> output;
    std::transform(source.begin(), source.end(), std::back_inserter(output), transformFunction);
    return output;
}
 
template <class T>
inline typename std::vector<T>::iterator vectorIndexOf(const vector<T> &vector, T value) {
    return std::find(vector.begin(), vector.end(), value);
}
 
template <class T>
inline bool vectorContains(const vector<T> &vector, T value) {
    if (vector.empty()) {
        return false;
    }
    return std::find(vector.begin(), vector.end(), value) != vector.end();
}
 
template <class T>
inline vector<T> &vectorRemoveIf(vector<T> &theVector, function<bool(const T &)> predicate) {
    auto it = theVector.begin();
    while (it != theVector.end()) {
        if (predicate(*it)) {
            it = theVector.erase(it);
        } else {
            ++it;
        }
    }
    return theVector;
}
 
template <class T>
inline vector<T> &vectorRemove(vector<T> &theVector, const T &item) {
    theVector.erase(std::remove(theVector.begin(), theVector.end(), item), theVector.end());
    return theVector;
}
 
template <class K, class V>
const optional<K> keyOfValueInMap(const map<K, V> *map, V searchedValue) {
    for (const auto &[key, value] : *map) {
        if (value == searchedValue) {
            return key;
        }
    }
    return {};
}
 
template <class TKey, class TValue>
bool areMapsEqual(const map<TKey, TValue> &map1, const map<TKey, TValue> &map2) {
    return map1.size() == map2.size() && std::equal(map1.begin(), map1.end(), map2.begin());
}
 
template <class TKey, class TValue>
vector<TKey> mapKeys(const map<TKey, TValue> &theMap) {
    vector<TKey> keys;
 
    if (!theMap.empty()) {
        for (auto it = theMap.begin(); it != theMap.end(); it++) {
            keys.push_back(it->first);
        }
    }
 
    return keys;
}
 
template <class TKey, class TValue>
vector<TValue> mapValuesConst(const map<TKey, const TValue> &theMap) {
    vector<TValue> values;
    for (auto it = theMap.begin(); it != theMap.end(); it++) {
        values.push_back((TValue)it->second);
    }
 
    return values;
}
 
template <class TKey, class TValue>
vector<TValue> mapValues(const map<TKey, TValue> &theMap) {
    vector<TValue> values;
    for (auto it = theMap.begin(); it != theMap.end(); it++) {
        values.push_back(it->second);
    }
 
    return values;
}
 
template <class TKey, class TValue>
vector<TValue *> mapValues(const map<TKey, TValue *> &theMap) {
    vector<TValue *> values;
    for (auto it = theMap.begin(); it != theMap.end(); it++) {
        values.push_back(it->second);
    }
    return values;
}
 
template <class TKey, class TValue>
inline void mapEraseIfExist(std::map<TKey, TValue> &theMap, const TKey &key) {
    auto it = theMap.find(key);
    if (it != theMap.end()) {
        theMap.erase(it);
    }
}
 
template <class K, class V>
string mapToString(const map<K, V> &theMap, const string &entriesSeparator = ",", const string &keyValueSeparator = "=") {
    ostringstream oss;
 
    if (!theMap.empty()) {
        for (auto it = theMap.begin(); it != theMap.end(); it++) {
            oss << it->first << keyValueSeparator << it->second << entriesSeparator;
        }
    }
 
    return oss.str();
}
 
system_clock::time_point timepointWithTime(optional<int> hours = {}, optional<int> minutes = {}, optional<int> seconds = {}, system_clock::time_point timePoint = system_clock::now());
 
unsigned long long timestampWithTime(optional<int> hours = {}, optional<int> minutes = {}, optional<int> seconds = {}, system_clock::time_point timePoint = system_clock::now());
 
unsigned long long toMillis(system_clock::time_point timePoint);
 
unsigned long long diffMillis(system_clock::time_point timePoint1, system_clock::time_point timePoint2);
 
unsigned long long nowMillis();
 
system_clock::time_point toTimePoint(unsigned long long timestampMillis);
 
template <typename K, typename V>
bool equals(const map<K, V> &map1, const map<K, V> &map2) {
    if (map1.size() != map2.size()) {
        return false;
    }
    for (auto it = map1.begin(); it != map1.end(); it++) {
        if (map2.find(it->first) == map2.end()) {
            return false;
        }
        if (map2.at(it->first) != map1.at(it->first)) {
            return false;
        }
    }
    return true;
}
 
string timePointToString(system_clock::time_point point);
 
string timePointToString(const std::chrono::steady_clock::time_point &tp);
 
char *copyStringChars(const string &str);
 
bool stringIsNumber(const string &str);
bool stringsAreEqualCaseInsensitive(const string &a, const string &b);
bool findSubString(const string str, const string sub);
 
template <typename T>
T enforceBounds(T valueToBound, T min, T max) {
    return valueToBound < min ? min : (valueToBound > max ? max : valueToBound);
}
 
struct FloatSizedArray {
    float *array = nullptr;
    unsigned size = 0;
};
 
float randomFloat(float aBound, float bBound);
 
const string ALPHABETICAL_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string ALPHANUMERIC_CHARS = ALPHABETICAL_CHARS + "0123456789";
 
string randomString(size_t length, const string &allowedChars = ALPHANUMERIC_CHARS);
string randomUUID();
 
char *longToCharArray(long value);
 
char *concatenateCharArray(const char *a, const char *b);
int randomInt(int lowerBound, int upperBound);
 
template <typename T>
inline string to_string_precision(const T value, const int n = 2) {
    std::ostringstream out;
    out << std::setprecision(n) << std::noshowpoint << value;
    return out.str();
}
template <typename T>
inline string to_string_precision_float(const T value) { return to_string_precision(value, 7); }
 
template <typename T>
inline string to_string_precision_double(const T value) { return to_string_precision(value, 16); }
 
template <typename T>
inline string to_string_precision_lngLat(const T value) { return to_string_precision(value, 9); }
 
template <typename T>
constexpr size_t size_of() {
    return reinterpret_cast<char *>(static_cast<T *>(nullptr) + 1) - reinterpret_cast<char *>(static_cast<T *>(nullptr));
}
 
template <typename T>
void pushInBytes(char *bytes, int &index, T data) {
    *((T *)(const void *)(bytes + index)) = data;
    index += size_of<T>();
}
 
struct DoubleSizedArray {
    double *array = nullptr;
    unsigned size = 0;
};
 
template <typename T>
T findMinValue(T *array, size_t size) {
    if (size <= 0) {
        return T();
    } // Retourne une valeur par défaut du type T
    T minValue = array[0];
    for (int i = 1; i < size; i++) {
        if (array[i] < minValue) {
            minValue = array[i];
        }
    }
    return minValue;
}
 
template <typename T>
T findMaxValue(T *array, size_t size) {
    if (size <= 0) {
        return T(); // Retourne une valeur par défaut du type T
    }
 
    T maxValue = array[0];
    for (int i = 1; i < size; i++) {
        if (array[i] > maxValue) {
            maxValue = array[i];
        }
    }
    return maxValue;
}
 
template <typename T>
T findMinRowValueFromArray(T **array, size_t size, int row) {
    if (size <= 0) {
        return T(); // Retourne une valeur par défaut du type T
    }
 
    T minValue = array[0][row];
    for (int i = 1; i < size; i++) {
        if (array[i][row] < minValue) {
            minValue = array[i][row];
        }
    }
    return minValue;
}
 
template <typename T>
T findMaxRowValueFromArray(T **array, size_t size, int row) {
    if (size <= 0) {
        return T(); // Retourne une valeur par défaut du type T
    }
 
    T maxValue = array[0][row];
    for (int i = 1; i < size; i++) {
        if (array[i][row] > maxValue) {
            maxValue = array[i][row];
        }
    }
    return maxValue;
}
 
float inchToCentimeter(float inchValue);
double inchToCentimeter(double inchValue);
 
string toStringTimestampMillis(unsigned long long timestampInMs, string format);
 
bool doublesEqual(double value1, double value2, double epsilon = 0.0000001);
bool floatsEqual(float value1, float value2, float epsilon = 0.0000001);
 
template <typename T>
T vectorGetRandomElement(const std::vector<T> *vec) {
    ASSERT("Cannot get an element from an empty vector.", !vec->empty());
 
    std::random_device rd;  // Generates a seed for the random number generator
    std::mt19937 gen(rd()); // Mersenne_twister_engine initialate with rd()
    std::uniform_int_distribution<> dis(0, vec->size() - 1);
    return vec->at(dis(gen));
}
 
bool stringContainsIgnoreCase(const string &theString, const string &searchedToken);
 
string truncateString(const string &input, size_t maxSize);
 
optional<any> getMapValueByPath(const map<string, any> &data, const string &path);
 
class CscException : public std::exception {
public:
    CscException(const string &errorMessage) noexcept;
    ~CscException() noexcept override = default;
    const char *what() const noexcept override;
    virtual const string &getErrorMessage() const;
 
private:
    const string errorMessage;
};
 
string getClassName(const std::type_info &paramsClass, bool withNamespace);
 
string getStackTrace();
 
string stringPadLeft(const string &input, size_t totalLength, char padChar = ' ');
string stringPadRight(const string &input, size_t totalLength, char padChar = ' ');
 
}
 
#endif