conscience_util.h File Reference

#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 <optional>
#include <string>
#include <utility>
#include <variant>
#include <random>

Go to the source code of this file.

Classes
struct	conscience_utils::IsStdFixedArrayStruct< A >
struct	conscience_utils::IsStdFixedArrayStruct< std::array< T, I > >
struct	conscience_utils::PointeeType< T >
struct	conscience_utils::PointeeType< U * >
struct	conscience_utils::PointeeType< const U * >
struct	conscience_utils::PointeeType< U *const >
struct	conscience_utils::PointeeType< const U *const >
struct	conscience_utils::SharedPtrTraits< T >
struct	conscience_utils::SharedPtrTraits< std::shared_ptr< U > >
class	conscience_utils::CannotParseEnumException
struct	conscience_utils::FloatSizedArray
struct	conscience_utils::DoubleSizedArray
class	conscience_utils::CscException

Namespaces
	conscience_utils

Macros
#define	deleteIfNotNull(objPointer)
#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)
#define	vectorSafeAt(vector, index, vectorDescription)   (vector)->at(index)
#define	mapSafeAt(map, key, mapDescription)   (map)->at(key)
#define	ASSERT(MSG, EXPR)   assert(((void)string((MSG)).c_str(), (EXPR)))
#define	COMMA   ,
#define	MACRO_PARENS   ()
#define	VARGS_STR_HELPER(...)   #__VA_ARGS__
#define	VARGS_STR(...)   VARGS_STR_HELPER(__VA_ARGS__)
#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, ...)
#define	FOR_EACH_AGAIN()   FOR_EACH_HELPER
#define	ENUM_TO_STRING_FILL_MAP(name)
#define	ENUM(ENUM_typeName, ...)

Functions
string	conscience_utils::trim (const string &str, const string &trimmedChars)
string	conscience_utils::floatArrayToString (float *floatArray, int size)
string	conscience_utils::doubleArrayToString (double *doubleArray, int size)
string	conscience_utils::intArrayToString (int *intArray, int size)
string	conscience_utils::boolToString (bool value)
string	conscience_utils::toStringCurrentTimeWithMillis ()
string	conscience_utils::toStringDateAndTime ()
vector< string > *	conscience_utils::splitString (const string &inputString, const string &delimiter, bool escapeDelimiterWithBackslash)
vector< float > *	conscience_utils::parseFloatList (string input, char separator)
vector< int > *	conscience_utils::parseIntList (string input, char separator)
map< string, string >	conscience_utils::parseMap (string input, const string &entriesSeparator, const string &keyValueSeparator, bool removeGlobalBracketIfExist)
optional< int >	conscience_utils::parseInt (const string &inputString)
optional< double >	conscience_utils::parseDouble (const string &inputString)
bool	conscience_utils::replaceInString (string &str, const string &from, const string &to, bool onlyFirst)
bool	conscience_utils::replaceAllInString (string &str, const string &from, const string &to)
void	conscience_utils::removeSpacesInString (string &str)
string	conscience_utils::toLowerCase (string &str)
string	conscience_utils::toUpperCase (string &str)
bool	conscience_utils::startsWithIgnoreCase (const string &str, const string &searchedPrefix)
void	conscience_utils::stringRemoveToken (string &s, const std::string_view &token)
string	conscience_utils::snakeCaseToPascalCase (const string &snakeCaseString)
template<class T >
string	conscience_utils::toStringOrNullString (T *object)
template<class T >
string	conscience_utils::toStringOrNullString (T object)
template<class T >
string	conscience_utils::vectorToString (const vector< T > &vector, const char *separator=",")
template<class T >
vector< const T * > *	conscience_utils::vectorOfPointerToConst (vector< T * > *theVector)
template<class T >
vector< const T * > &	conscience_utils::vectorOfPointerToConst (vector< T * > &&theVector)
template<class T >
vector< const T * > &	conscience_utils::vectorOfPointerToConst (vector< T * > &theVector)
template<class T >
const vector< const T * > &	conscience_utils::vectorOfPointerToConst (const vector< T * > &theVector)
template<class T >
vector< T >	conscience_utils::vectorsConcat (const vector< T > &vector1, const vector< T > &vector2)
template<class T >
vector< T * > *	conscience_utils::vectorCloneDeep (const vector< T * > *source)
template<class T >
void	conscience_utils::vectorPushIfMissing (vector< T > &vector, T value)
template<class T , class R >
vector< R >	conscience_utils::vectorTransform (const vector< T > &source, function< R(const T &item)> transformFunction)
template<class T >
std::vector< T >::iterator	conscience_utils::vectorIndexOf (const vector< T > &vector, T value)
template<class T >
bool	conscience_utils::vectorContains (const vector< T > &vector, T value)
template<class T >
vector< T > &	conscience_utils::vectorRemoveIf (vector< T > &theVector, function< bool(const T &)> predicate)
template<class T >
vector< T > &	conscience_utils::vectorRemove (vector< T > &theVector, const T &item)
template<class K , class V >
const optional< K >	conscience_utils::keyOfValueInMap (const map< K, V > *map, V searchedValue)
template<class TKey , class TValue >
bool	conscience_utils::areMapsEqual (const map< TKey, TValue > &map1, const map< TKey, TValue > &map2)
template<class TKey , class TValue >
vector< TKey >	conscience_utils::mapKeys (const map< TKey, TValue > &theMap)
template<class TKey , class TValue >
vector< TValue >	conscience_utils::mapValuesConst (const map< TKey, const TValue > &theMap)
template<class TKey , class TValue >
vector< TValue >	conscience_utils::mapValues (const map< TKey, TValue > &theMap)
template<class TKey , class TValue >
vector< TValue * >	conscience_utils::mapValues (const map< TKey, TValue * > &theMap)
template<class TKey , class TValue >
void	conscience_utils::mapEraseIfExist (std::map< TKey, TValue > &theMap, const TKey &key)
template<class K , class V >
string	conscience_utils::mapToString (const map< K, V > &theMap, const string &entriesSeparator=",", const string &keyValueSeparator="=")
system_clock::time_point	conscience_utils::timepointWithTime (optional< int > hours, optional< int > minutes, optional< int > seconds, system_clock::time_point timePoint)
unsigned long long	conscience_utils::timestampWithTime (optional< int > hours, optional< int > minutes, optional< int > seconds, system_clock::time_point timePoint)
unsigned long long	conscience_utils::toMillis (system_clock::time_point timePoint)
unsigned long long	conscience_utils::diffMillis (system_clock::time_point timePoint1, system_clock::time_point timePoint2)
unsigned long long	conscience_utils::nowMillis ()
system_clock::time_point	conscience_utils::toTimePoint (unsigned long long timestampMillis)
template<typename K , typename V >
bool	conscience_utils::equals (const map< K, V > &map1, const map< K, V > &map2)
string	conscience_utils::timePointToString (system_clock::time_point point)
string	conscience_utils::timePointToString (const std::chrono::steady_clock::time_point &tp)
char *	conscience_utils::copyStringChars (const string &str)
bool	conscience_utils::stringIsNumber (const string &str)
bool	conscience_utils::stringsAreEqualCaseInsensitive (const string &a, const string &b)
bool	conscience_utils::findSubString (const string str, const string sub)
template<typename T >
T	conscience_utils::enforceBounds (T valueToBound, T min, T max)
float	conscience_utils::randomFloat (float aBound, float bBound)
string	conscience_utils::randomString (size_t length, const string &allowedChars)
string	conscience_utils::randomUUID ()
char *	conscience_utils::longToCharArray (long value)
char *	conscience_utils::concatenateCharArray (const char *a, const char *b)
int	conscience_utils::randomInt (int lowerBound, int upperBound)
template<typename T >
string	conscience_utils::to_string_precision (const T value, const int n=2)
template<typename T >
string	conscience_utils::to_string_precision_float (const T value)
template<typename T >
string	conscience_utils::to_string_precision_double (const T value)
template<typename T >
string	conscience_utils::to_string_precision_lngLat (const T value)
template<typename T >
constexpr size_t	conscience_utils::size_of ()
template<typename T >
void	conscience_utils::pushInBytes (char *bytes, int &index, T data)
template<typename T >
T	conscience_utils::findMinValue (T *array, size_t size)
template<typename T >
T	conscience_utils::findMaxValue (T *array, size_t size)
template<typename T >
T	conscience_utils::findMinRowValueFromArray (T **array, size_t size, int row)
template<typename T >
T	conscience_utils::findMaxRowValueFromArray (T **array, size_t size, int row)
float	conscience_utils::inchToCentimeter (float inchValue)
double	conscience_utils::inchToCentimeter (double inchValue)
string	conscience_utils::toStringTimestampMillis (unsigned long long timestampInMs, string format)
bool	conscience_utils::doublesEqual (double value1, double value2, double epsilon)
bool	conscience_utils::floatsEqual (float value1, float value2, float epsilon)
template<typename T >
T	conscience_utils::vectorGetRandomElement (const std::vector< T > *vec)
bool	conscience_utils::stringContainsIgnoreCase (const string &theString, const string &searchedToken)
string	conscience_utils::truncateString (const string &input, size_t maxSize)
optional< any >	conscience_utils::getMapValueByPath (const map< string, any > &data, const string &path)
string	conscience_utils::getClassName (const std::type_info &paramsClass, bool withNamespace)
string	conscience_utils::getStackTrace ()
string	conscience_utils::stringPadLeft (const string &input, size_t totalLength, char padChar)
string	conscience_utils::stringPadRight (const string &input, size_t totalLength, char padChar)

Variables
template<class TTestedType , class TPointee >
concept	conscience_utils::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>
constexpr bool	conscience_utils::IsTemplatedType = false
template<template< class... > class T, class... Args>
constexpr bool	conscience_utils::IsTemplatedType< T< Args... >, T > = true
template<typename T >
concept	conscience_utils::IsOptional = IsTemplatedType<T, std::optional>
template<typename T >
concept	conscience_utils::IsVector = IsTemplatedType<T, std::vector>
template<class T >
constexpr bool	conscience_utils::IsStdFixedArray = IsStdFixedArrayStruct<T>::value
template<typename T >
concept	conscience_utils::IsMap = IsTemplatedType<T, std::map>
template<typename T >
concept	conscience_utils::IsEnum = std::is_enum_v<T>
template<typename T >
concept	conscience_utils::IsStarPointer = PointeeType<std::remove_cvref_t<T>>::isPointer
template<typename T >
concept	conscience_utils::IsSharedPointer = SharedPtrTraits<std::remove_cvref_t<T>>::isSharedPtr
static const string	conscience_utils::ALL_SPACES_STRING = " \n\t\r"
const string	conscience_utils::ALPHABETICAL_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const string	conscience_utils::ALPHANUMERIC_CHARS = ALPHABETICAL_CHARS + "0123456789"

Macro Definition Documentation

ASSERT

#define ASSERT	(		MSG,
			EXPR
	)		assert(((void)string((MSG)).c_str(), (EXPR)))

COMMA

#define COMMA   ,

deleteIfNotNull

#define deleteIfNotNull

(

objPointer

)

Value:

    if (objPointer) {               \
        delete objPointer;          \
        objPointer = nullptr;       \
    }

deleteItems

#define deleteItems

(

vectorOfItems

)

[](const auto &theVector) { for (const auto * item : theVector) { delete item; } }(vectorOfItems)

deleteValues

#define deleteValues

(

mapOfKeysAndValues

)

[](const auto &theMap) { for (auto it = theMap.begin(); it != theMap.end(); it++) { delete it->second; } }(mapOfKeysAndValues)

ENUM

#define ENUM	(		ENUM_typeName,
			...
	)

ENUM_TO_STRING_FILL_MAP

#define ENUM_TO_STRING_FILL_MAP

(

name

)

Value:

    {                                                                 \
        /* 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;                                \
    }

FOR_EACH

#define FOR_EACH	(		macro,
			...
	)		__VA_OPT__(MACRO_EXPAND(FOR_EACH_HELPER(macro, __VA_ARGS__)))

FOR_EACH_AGAIN

#define FOR_EACH_AGAIN

(

)

FOR_EACH_HELPER

FOR_EACH_HELPER

#define FOR_EACH_HELPER	(		macro,
			a1,
			...
	)

Value:

    macro(a1)                           \
        __VA_OPT__(FOR_EACH_AGAIN MACRO_PARENS(macro, __VA_ARGS__))

MACRO_EXPAND

#define MACRO_EXPAND

(

arg

)

MACRO_EXPAND1(MACRO_EXPAND1(MACRO_EXPAND1(MACRO_EXPAND1(arg))))

MACRO_EXPAND1

#define MACRO_EXPAND1

(

arg

)

MACRO_EXPAND2(MACRO_EXPAND2(MACRO_EXPAND2(MACRO_EXPAND2(arg))))

MACRO_EXPAND2

#define MACRO_EXPAND2

(

arg

)

MACRO_EXPAND3(MACRO_EXPAND3(MACRO_EXPAND3(MACRO_EXPAND3(arg))))

MACRO_EXPAND3

#define MACRO_EXPAND3

(

arg

)

MACRO_EXPAND4(MACRO_EXPAND4(MACRO_EXPAND4(MACRO_EXPAND4(arg))))

MACRO_EXPAND4

#define MACRO_EXPAND4

(

arg

)

arg

MACRO_PARENS

#define MACRO_PARENS   ()

mapSafeAt

#define mapSafeAt	(		map,
			key,
			mapDescription
	)		(map)->at(key)

VARGS_STR

#define VARGS_STR

(

...

)

VARGS_STR_HELPER(__VA_ARGS__)

VARGS_STR_HELPER

#define VARGS_STR_HELPER

(

...

)

#__VA_ARGS__

vectorSafeAt

#define vectorSafeAt	(		vector,
			index,
			vectorDescription
	)		(vector)->at(index)