# namespace std_ext

## Overview

Extensions to the standard libraries. More…

    namespace std_ext {

    // classes

    template <typename T>
    class AtomicQueue;

    class AuthenticationError;
    class NotImplementedError;
    class OutOfBounds;
    class UnhandledConditionError;

    // global variables

    const std::string WHITESPACES = " \t\n\r\f\v";

    // global functions

    void StringTo(const std::string& str, float& out);
    void StringTo(const std::string& str, double& out);
    void StringTo(const std::string& str, int32_t& out);
    void StringTo(const std::string& str, int64_t& out);
    void StringTo(const std::string& str, uint32_t& out);
    void StringTo(const std::string& str, uint64_t& out);
    std::wstring ToWString(const std::string& text);
    std::string ToStdString(const std::wstring& text);
    size_t CountOccurrences(const std::string& text, const std::string& key_to_search);
    size_t CountOccurrences(const std::string& text, const std::string& key_to_search, const size_t& off, const size_t& length);
    std::string Replace(const std::string& text, const std::string& key_to_search, const std::string& replace_text);
    std::string Replace(const std::string& text, const std::map<std::string, std::string>& replacement_map);

    template <typename T>
    void Replace(std::vector<T>& vector, const T old_elem, const T new_elem);

    std::string BoolToString(const bool value);
    std::string ToStringAutoPrecision(const double value, int max_digits = 6);

    template <typename T>
    std::string ToStringWithPrecision(const T value, const int n = 6);

    template <typename T>
    std::string ToStringWithZeroes(const T value, const int n = 6);

    template <typename T>
    std::string ToString(const std::vector<T>& container, const std::string& separator = ", ");

    std::string ToString(const std::vector<std::string>& container, const std::string& separator = ", ");

    template <typename T>
    std::string ToStringWithThousandSeparators(const T& input);

    void MakeUppercase(char* text);
    void MakeUppercase(std::string& text);
    std::string Uppercase(const std::string& text);
    void MakeLowercase(char* text);
    void MakeLowercase(std::string& text);
    std::string Lowercase(const std::string& text);
    bool EndsWith(const std::string& ending, const std::string& text);
    bool Contains(const std::string& substring, const std::string& text);
    bool Contains(const char character, const std::string& text);
    std::string ReplacePatternWithNumber(const std::string& base_string, const std::string& pattern, const int number);

    template <typename T>
    bool Contains(const T& element, const std::initializer_list<T>& list);

    template <typename Type>
    bool Contains(const Type& element, const std::vector<Type>& vector);

    template <typename Type>
    std::optional<size_t> GetIndex(const Type element, const std::vector<Type>& vector);

    template <typename Type>
    bool Contains(const Type element, const std::set<Type>& set);

    template <typename T1, typename T2>
    bool Contains(const T1 element, const std::unordered_set<T1, T2>& set);

    template <typename T1, typename T2>
    bool Contains(const T1 element, const std::map<T1, T2>& map);

    template <typename T1, typename T2>
    bool Contains(const T1 element, const std::unordered_map<T1, T2>& map);

    template <typename Type>
    bool ContainsCommonElement(const std::vector<Type>& elements1, const std::set<Type>& elements2);

    template <typename Type>
    void SortAndRemoveDuplicates(std::vector<Type>& vec);

    template <typename Type>
    std::vector<Type> RemoveDuplicates(std::vector<Type>& vector);

    template <typename Type>
    bool Erase(const Type& element, std::vector<Type>& vector);

    template <typename Type>
    bool Erase(const Type& element, std::set<Type>& set);

    template <typename IndicesType, typename Type>
    std::vector<IndicesType> CollectIndices(const std::vector<Type>& vector, const Type value);

    template <typename T, typename F>
    void Foreach(const T& container, const F& Function);

    template <typename T>
    auto MaxIt(const std::vector<T>& vector);

    template <typename T>
    auto MinIt(const std::vector<T>& vector);

    template <typename T>
    T Max(const std::vector<T>& vector);

    template <typename T>
    T Min(const std::vector<T>& vector);

    template <typename T>
    T Max(const T val);

    template <typename T, typename ... TS>
    T Max(const T val1, const T val2, const TS ... vals);

    template <typename T>
    T Min(const T val);

    template <typename T, typename... TS>
    T Min(const T val1, const T val2, const TS ... vals);

    template <typename T, typename F>
    auto Max(const std::vector<T>& vector, const F& Function);

    template <typename T, typename F>
    auto Min(const std::vector<T>& vector, const F& Function);

    template <typename T, typename F>
    auto MaxValue(const std::vector<T>& vector, const F& Function);

    template <typename T, typename F>
    auto MinValue(const std::vector<T>& vector, const F& Function);

    template <typename T, typename F>
    auto MiddleValue(const std::vector<T>& vector, const F& Function);

    template <typename T>
    auto Accumulate(const std::vector<T>& vector, const T start_value);

    template <typename T>
    auto Sum(const std::vector<T>& vector);

    template <typename T>
    auto Average(const std::vector<T>& vector);

    template <typename T, typename F>
    auto Accumulate(const std::vector<T>& vector, const T initial_value, const F& function);

    template <typename T, typename F>
    auto Sum(const std::vector<T>& vector, const F& function);

    template <typename T, typename F>
    float Average(const std::vector<T>& vector, const F& function);

    template <typename T>
    auto Median(const std::vector<T>& vector);

    template <typename T, typename S>
    void InsertBack(T& target, const S& source);

    template <typename T, typename S>
    void InsertFront(T& target, const S& source);

    template <typename T, typename S>
    void InsertTo(T& target, const S& source);

    template <typename Type>
    void EmplaceBackUnique(const Type& element, std::vector<Type>& vector);

    std::string& TrimBegin(std::string& s, const std::string& t = WHITESPACES);
    std::string& TrimEnd(std::string& s, const std::string& t = WHITESPACES);
    std::string& Trim(std::string& s, const std::string& t = WHITESPACES);
    std::string EndWithASingleSlash(const std::string& s);
    std::vector<std::string> Parse(const std::string& text, const std::string& separators = WHITESPACES);

    template <typename T>
    void Read(T& val, std::istream& str);

    template <typename T>
    T Read(std::istream& str);

    template <typename T>
    void Write(const T val, std::ostream& str);

    void Read(std::string&, std::istream&);
    void Write(const std::string&, std::ostream&);
    void ReadString(std::string& text, std::istream& str);
    std::string ReadString(std::istream& str);
    void WriteString(const std::string& text, std::ostream& str);

    template <class C, class T>
    auto Find(C& container, const T& value);

    template <class C, class F>
    auto Transformed(const C& container, F Function);

    template <class C, class P>
    auto AllOf(const C& container, const P& Predicate);

    template <class C, class P>
    auto AnyOf(const C& container, const P& Predicate);

    template <class C, class P>
    auto AnyOfW(C& container, const P& Predicate);

    template <class C, class P>
    auto NoneOf(const C& container, const P& Predicate);

    template <class C, class T>
    auto Count(const C& container, const T& val);

    template <class C, class P>
    auto CountIf(const C& container, const P& Predicate);

    template <class C, class P>
    auto FindIf(C& container, const P& Predicate);

    template <class C, class P>
    auto RevFindIf(C& container, const P& Predicate);

    template <class C, class P>
    auto FindIfPtr(C& container, const P& Predicate);

    template <class C, class P>
    auto EraseIf(C& container, const P& Predicate);

    template <class C, class P>
    auto SelectIf(const C& container, const P& Predicate);

    template <class C, class P>
    std::pair<C, C> Partition(const C& container, const P& Predicate);

    template <class T, class P>
    std::vector<std::pair<size_t, size_t>> FindIntervals(const std::vector<T>& vec, const P& Predicate);

    template <typename T>
    std::vector<T> Joined(const std::vector<std::vector<T>>& vector_of_vectors);

    template <typename T, typename F>
    std::vector<T> JoinTransformed(const std::vector<std::vector<T>>& vector_of_vectors, const F& Function);

    template <typename F, typename O>
    auto Bind1(F method, O object);

    bool IsASCII(const std::string& s);

    } // namespace std_ext

## Detailed Documentation

Extensions to the standard libraries.

### Global Functions

    std::wstring ToWString(const std::string& text)

Convert single-byte std::string to std::wstring.

This only works if all the characters are single byte, i.e. ASCII or ISO-8859-1. Anything multi-byte will fail miserably, including UTF-8. (https://stackoverflow.com/a/8969776/2621721)

    std::string ToStdString(const std::wstring& text)

Convert std::wstring to std::string.

    size_t CountOccurrences(const std::string& text, const std::string& key_to_search)

Counts how many of specified key_to_search substrings does text contain.

    size_t CountOccurrences(const std::string& text, const std::string& key_to_search, const size_t& off, const size_t& length)

Counts how many of specified key_to_search substrings does text contain in a specific range.

    std::string Replace(const std::string& text, const std::string& key_to_search, const std::string& replace_text)

Replaces all occurrences of key_to_search with replace_text in specified text.

    std::string Replace(const std::string& text, const std::map<std::string, std::string>& replacement_map)

Replaces all occurrences of key_to_search with replace_text in specified text.

Parameters:

replacement_map | Contains pairs of <key_to_search, replace_text>.

    template <typename T>
    void Replace(std::vector<T>& vector, const T old_elem, const T new_elem)

Replaces all occurrences of old_elem in a vector with a new_elem.

    std::string BoolToString(const bool value)

Converts bool to string (“true” or “false”).

    std::string ToStringAutoPrecision(const double value, int max_digits = 6)

Converts double to string with decimal digits until max_digits are reached.

Parameters:

value | Value which will be converted to string.
max_digits | Value that represents maximum number of decimal digits that will be converted.

    template <typename T>
    std::string ToStringWithPrecision(const T value, const int n = 6)

Converts type to string with specified number of decimal digits.

    template <typename T>
    std::string ToStringWithZeroes(const T value, const int n = 6)

Converts int to string with zeros at the beginning to match specified number of digits.

    template <typename T>
    std::string ToString(const std::vector<T>& container, const std::string& separator = ", ")

Converts all values in the vector to a string and joins them using specified separator.

    std::string ToString(const std::vector<std::string>& container, const std::string& separator = ", ")

Joins all values in a string vector using specified separator.

    template <typename T>
    std::string ToStringWithThousandSeparators(const T& input)

Converts a numeric value to string using thousand separators.

Example: 10235 => “10’235” 1000000000 => 1’000’000’000

    void MakeUppercase(char* text)

Converts text into all uppercase.

    void MakeUppercase(std::string& text)

Converts text into all uppercase.

    std::string Uppercase(const std::string& text)

Converts text into all uppercase.

    void MakeLowercase(char* text)

Converts text into all lowercase.

    void MakeLowercase(std::string& text)

Converts text into all lowercase.

    std::string Lowercase(const std::string& text)

Converts text into all lowercase.

    bool EndsWith(const std::string& ending, const std::string& text)

Checks if the text ends with a string.

    bool Contains(const std::string& substring, const std::string& text)

Checks if the text contains substring.

    bool Contains(const char character, const std::string& text)

Checks if the text contains character.

    std::string ReplacePatternWithNumber(const std::string& base_string, const std::string& pattern, const int number)

Replaces a patter in specified string with a number.

Example: (“example-###”, “#”, 2)> “example-002”

    template <typename T>
    bool Contains(const T& element, const std::initializer_list<T>& list)

Check if the initializer list contains an element.

    template <typename Type>
    bool Contains(const Type& element, const std::vector<Type>& vector)

Check if the vector contains an element.

    template <typename Type>
    std::optional<size_t> GetIndex(const Type element, const std::vector<Type>& vector)

If an element exists in the vector, returns its index.

    template <typename Type>
    bool Contains(const Type element, const std::set<Type>& set)

Check if the set contains an element.

    template <typename T1, typename T2>
    bool Contains(const T1 element, const std::unordered_set<T1, T2>& set)

Check if an unordered_set contains an element.

    template <typename T1, typename T2>
    bool Contains(const T1 element, const std::map<T1, T2>& map)

Check if the mat contains an element.

    template <typename T1, typename T2>
    bool Contains(const T1 element, const std::unordered_map<T1, T2>& map)

Check if an unordered_map contains an element.

    template <typename Type>
    bool ContainsCommonElement(const std::vector<Type>& elements1, const std::set<Type>& elements2)

Check if there is at least a single common element in two vectors.

    template <typename Type>
    void SortAndRemoveDuplicates(std::vector<Type>& vec)

Sorts the array and removes duplicate elements.

    template <typename Type>
    std::vector<Type> RemoveDuplicates(std::vector<Type>& vector)

Returns vector similar to input, but without duplicate elements.

    template <typename Type>
    bool Erase(const Type& element, std::vector<Type>& vector)

Removes an element from the vector. Returns success.

    template <typename Type>
    bool Erase(const Type& element, std::set<Type>& set)

Removes an element with from the set. Returns success.

    template <typename IndicesType, typename Type>
    std::vector<IndicesType> CollectIndices(const std::vector<Type>& vector, const Type value)

Collect all indices of elements in a vector with a specified value.

    template <typename T, typename F>
    void Foreach(const T& container, const F& Function)

Execute a function for every element in the container.

    template <typename T>
    auto MaxIt(const std::vector<T>& vector)

Finds a maximum value in a vector, return an iterator pointing to it.

    template <typename T>
    auto MinIt(const std::vector<T>& vector)

Finds a minimal value in a vector, return an iterator pointing to it.

    template <typename T>
    T Max(const std::vector<T>& vector)

Finds a maximum value in a vector.

    template <typename T>
    T Min(const std::vector<T>& vector)

Finds a minimal value in a vector.

    template <typename T>
    T Max(const T val)

Finds a maximum value from a single element. Boundary case for the variadic expansion.

    template <typename T, typename ... TS>
    T Max(const T val1, const T val2, const TS ... vals)

Finds a maximum value from variadic argument list.

    template <typename T>
    T Min(const T val)

Finds a minimal value from a single element. Boundary case for the variadic expansion.

    template <typename T, typename... TS>
    T Min(const T val1, const T val2, const TS ... vals)

Finds a minimal value from variadic argument list.

    template <typename T, typename F>
    auto Max(const std::vector<T>& vector, const F& Function)

Finds the object in a vector, which when transformed by a function gives a maximum value.

    template <typename T, typename F>
    auto Min(const std::vector<T>& vector, const F& Function)

Finds the object in a vector, which when transformed by a function gives a minimal value.

    template <typename T, typename F>
    auto MaxValue(const std::vector<T>& vector, const F& Function)

Finds a maximum value transformed by a function in a vector.

    template <typename T, typename F>
    auto MinValue(const std::vector<T>& vector, const F& Function)

Finds a minimal value transformed by a function in a vector.

    template <typename T, typename F>
    auto MiddleValue(const std::vector<T>& vector, const F& Function)

Finds a middle (average of min, max) value transformed by a function in a vector.

    template <typename T>
    auto Accumulate(const std::vector<T>& vector, const T start_value)

Wrapper for std::accumulate.

    template <typename T>
    auto Sum(const std::vector<T>& vector)

Sum all elements in a vector.

    template <typename T>
    auto Average(const std::vector<T>& vector)

Compute average element of a vector. In case of empty vector, return 0.

    template <typename T, typename F>
    auto Accumulate(const std::vector<T>& vector, const T initial_value, const F& function)

Wrapper for std::accumulate - https://en.cppreference.com/w/cpp/algorithm/accumulate - values transformed by a function.

This will make a sum of every element of the input vector transformed by a function plus the initial element.

Parameters:

vector | The input vector (will be transformed by a function).
initial_value | The initial_value will be added to the resulting sum.
function | The function that will transform every element of the vector.

    template <typename T, typename F>
    auto Sum(const std::vector<T>& vector, const F& function)

Sum all elements in a vector transformed by a function.

    template <typename T, typename F>
    float Average(const std::vector<T>& vector, const F& function)

Compute average element of a vector transformed by a function. In case of empty vector, return 0.0f.

    template <typename T>
    auto Median(const std::vector<T>& vector)

Compute median value of a vector. In case of empty vector, return 0.

    template <typename T, typename S>
    void InsertBack(T& target, const S& source)

Insert the source vector to the back of target vector.

    template <typename T, typename S>
    void InsertFront(T& target, const S& source)

Insert the source vector to the front of target vector.

    template <typename T, typename S>
    void InsertTo(T& target, const S& source)

Insert the source container to the target container.

    template <typename Type>
    void EmplaceBackUnique(const Type& element, std::vector<Type>& vector)

Emplace back an element if it is unique to the vector.

    std::string& TrimBegin(std::string& s, const std::string& t = WHITESPACES)

Trims characters from beginning of string (left).

    std::string& TrimEnd(std::string& s, const std::string& t = WHITESPACES)

Trims characters from end of string (right).

    std::string& Trim(std::string& s, const std::string& t = WHITESPACES)

Trims from both ends of string (left & right).

    std::string EndWithASingleSlash(const std::string& s)

Trim the end of a string to removes forward and backward slashes (/, ) and add one single forward slash /.

    std::vector<std::string> Parse(const std::string& text, const std::string& separators = WHITESPACES)

Parses the input text to sub strings by a given list of separators.

    template <typename T>
    void Read(T& val, std::istream& str)

Reads a value from the binary stream, number of bytes red is determined by a template type.

    template <typename T>
    T Read(std::istream& str)

Reads a value from the binary stream, number of bytes red is determined by a template type.

    template <typename T>
    void Write(const T val, std::ostream& str)

Writes a value to the binary stream, bytes written are determined by a template type.

    void ReadString(std::string& text, std::istream& str)

Reads a string from the binary stream.

    std::string ReadString(std::istream& str)

Reads a value from the binary stream, number of bytes red is determined by a template type.

    void WriteString(const std::string& text, std::ostream& str)

Writes a value to the binary stream, number of bytes written is determined by a template type.

    template <class C, class T>
    auto Find(C& container, const T& value)

Simplified wrapper for std::find.

    template <class C, class F>
    auto Transformed(const C& container, F Function)

Simplified wrapper for std::transform.

    template <class C, class P>
    auto AllOf(const C& container, const P& Predicate)

Simplified wrapper for std::all_of.

    template <class C, class P>
    auto AnyOf(const C& container, const P& Predicate)

Simplified wrapper for std::any_of.

    template <class C, class P>
    auto AnyOfW(C& container, const P& Predicate)

Simplified wrapper for std::any_of (writable).

    template <class C, class P>
    auto NoneOf(const C& container, const P& Predicate)

Simplified wrapper for std::none_of.

    template <class C, class T>
    auto Count(const C& container, const T& val)

Simplified wrapper for std::count.

    template <class C, class P>
    auto CountIf(const C& container, const P& Predicate)

Simplified wrapper for std::count_if.

    template <class C, class P>
    auto FindIf(C& container, const P& Predicate)

Simplified wrapper for std::find_if.

    template <class C, class P>
    auto RevFindIf(C& container, const P& Predicate)

Simplified wrapper for reversed std::find_if.

    template <class C, class P>
    auto FindIfPtr(C& container, const P& Predicate)

Simplified wrapper for std::find_if that expects a vector of pointers as input and returns a pointer.

The motivation is instead of returning an iterator to a pointer, to return the pointer itself or null.

Returns:

Return the pointer itself if found, else it returns null pointer.

    template <class C, class P>
    auto EraseIf(C& container, const P& Predicate)

Simplified wrapper for std::remove_if and std::erase.

    template <class C, class P>
    auto SelectIf(const C& container, const P& Predicate)

Copies all elements fulfilling a given condition into a new vector. Uses std::copy_if.

    template <class C, class P>
    std::pair<C, C> Partition(const C& container, const P& Predicate)

Partitions all elements based on a given condition.

Uses std::partition_copy.

Returns:

A pair of container. The first contains all elements that satisfy the condition, the second all elements that do not.

    template <class T, class P>
    std::vector<std::pair<size_t, size_t>> FindIntervals(const std::vector<T>& vec, const P& Predicate)

Finds all intervals on the vector where a given condition holds.

Returns:

A vector of interval indices pairs.

    template <typename F, typename O>
    auto Bind1(F method, O object)

Creates binding for an object method with a single argument.

    bool IsASCII(const std::string& s)

Check std::string for non-ASCII characters.