Utility.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/StringStream.hpp"
 
#include <algorithm>
#include <bit>
#include <cctype>
#include <cmath>
#include <concepts>
#include <functional>
#include <iomanip>
#include <iterator>
#include <memory>
#include <sstream>
#include <type_traits>
 
namespace CeresEngine {
 
    // Removes all entries from the specified container which are equal to the specified type.
    template<typename TCollection, typename TValue> void eraseAll(TCollection& collection, const TValue& value) {
        collection.erase(std::remove(std::begin(collection), std::end(collection), value), std::end(collection));
    }
 
    // Removes all entries from the specified container for which the specified predicate is true.
    template<typename TCollection, typename TPredicate> void eraseAllIf(TCollection& collection, TPredicate pred) {
        collection.erase(std::remove_if(std::begin(collection), std::end(collection), pred), std::end(collection));
    }
 
    // Moves all entries from the source into the destination.
    template<typename TCollectionSrc, typename TCollectionDest> void moveAll(TCollectionSrc& src, TCollectionDest& dst) {
        std::move(std::begin(src), std::end(src), std::back_inserter(dst));
        src.clear();
    }
 
    // Moves all entries from the source into the destination for which the specified predicate is true.
    template<typename TCollectionSrc, typename TCollectionDest, typename TPredicate>
    void moveAllIf(TCollectionSrc& src, TCollectionDest& dst, TPredicate pred) {
        for(auto it = src.begin(); it != src.end();) {
            if(pred(*it)) {
                dst.push_back(*it);
                it = src.erase(it);
            } else {
                ++it;
            }
        }
    }
 
    // Replaces all occurances of 'from' in the string 's' by 'to'.
    template<class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
    void replace(std::basic_string<CharT, Traits, Allocator>& s, const std::basic_string<CharT, Traits, Allocator>& from,
        const std::basic_string<CharT, Traits, Allocator>& to) {
        using T = std::basic_string<CharT, Traits, Allocator>;
        for(typename T::size_type pos = 0; (pos = s.find(from, pos)) != T::npos; pos += to.size()) {
            s.replace(pos, from.size(), to);
        }
    }
 
    // Replaces all occurances of 'from' in the string 's' by 'to'.
    template<class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
    void replace(std::basic_string<CharT, Traits, Allocator>& s, const char* from, const char* to) {
        Replace(s, std::basic_string<CharT, Traits, Allocator>(from), std::basic_string<CharT, Traits, Allocator>(to));
    }
 
    // Replaces all occurances of 'from' in the string 's' by 'to'.
    template<class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
    void replace(std::basic_string<CharT, Traits, Allocator>& s, const std::basic_string<CharT, Traits, Allocator>& from, const char* to) {
        Replace(s, from, std::basic_string<CharT, Traits, Allocator>(to));
    }
 
    // Replaces all occurances of 'from' in the string 's' by 'to'.
    template<class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
    void replace(std::basic_string<CharT, Traits, Allocator>& s, const char* from, const std::basic_string<CharT, Traits, Allocator>& to) {
        Replace(s, std::basic_string<CharT, Traits, Allocator>(from), to);
    }
 
    // Parses a number from the specified string with std::stoi, std::stoll, std::stof, or std::stod
    template<typename T> inline T fromStringOrDefault(const StringView& s) {
        throw std::runtime_error("default template of fromStringOrDefault<T> not implemented");
    }
 
    // Returns true if the specified string contains a hexadecimal number.
    inline bool isHexLiteral(const StringView& s) { return (s.size() >= 3 && s[0] == '0' && ::toupper(s[1]) == 'X'); }
 
    template<> inline int fromStringOrDefault<int>(const StringView& s) {
        try {
            return std::stoi(std::string(s), nullptr, (isHexLiteral(s) ? 16 : 10));
        } catch(const std::exception&) {
            return 0;
        }
    }
 
    template<> inline long long fromStringOrDefault<long long>(const StringView& s) {
        try {
            return std::stoll(std::string(s), nullptr, (isHexLiteral(s) ? 16 : 10));
        } catch(const std::exception&) {
            return 0ll;
        }
    }
 
    template<> inline unsigned long fromStringOrDefault<unsigned long>(const StringView& s) {
        try {
            return std::stoul(std::string(s), nullptr, (isHexLiteral(s) ? 16 : 10));
        } catch(const std::exception&) {
            return 0ul;
        }
    }
 
    template<> inline float fromStringOrDefault<float>(const StringView& s) {
        try {
            return std::stof(std::string(s));
        } catch(const std::exception&) {
            return 0.0f;
        }
    }
 
    template<> inline double fromStringOrDefault<double>(const StringView& s) {
        try {
            return std::stod(std::string(s));
        } catch(const std::exception&) {
            return 0.0;
        }
    }
 
    // Transforms the specified string to upper case.
    template<typename T> void toUpper(T& s) { std::transform(std::begin(s), std::end(s), std::begin(s), ::toupper); }
 
    template<typename T, typename Allocator>
    void mergeString(BasicString<T, Allocator>& dst, const BasicString<T, Allocator>& src, const T& keepDst, const T& ignoreSrc) {
        const auto nDst = dst.size();
        const auto nSrc = src.size();
 
        typename BasicString<T, Allocator>::size_type i = 0;
 
        for(; i < nDst; ++i) {
            if(i < nSrc) {
                if(dst[i] != keepDst && src[i] != ignoreSrc) {
                    dst[i] = src[i];
                }
            } else {
                return;
            }
        }
 
        if(i < nSrc) {
            dst.append(src.substr(i));
        }
    }
 
    // Returns a hexa-decimal string of the specified integral value.
    template<typename T> String toHexString(const T& i, const String& prefix = "0x") {
        StringStream s;
        s << prefix << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex << i;
        return s.str();
    }
 
    // Returns the number of digits of the specified integral type.
    template<typename T> int numDigits(T n) {
        static_assert(std::is_integral<T>::value, "NumDigits template only allows integral types");
 
        int digits = (n < 0 ? 1 : 0);
 
        while(n != 0) {
            n /= 10;
            ++digits;
        }
 
        return digits;
    }
 
    // Equivalent to C++14's 'std::exchange(ptr, nullptr)'.
    template<typename T> SPtr<T> exchangeWithNull(SPtr<T>& ptr) {
        auto result = ptr;
        ptr.reset();
        return result;
    }
 
    enum class Endian {
        Big = UInt8(std::endian::big),
        Little = UInt8(std::endian::little),
        Native = UInt8(std::endian::native),
    };
 
    namespace impl {
        template<Endian, typename T> struct ByteSwapper {
            T operator()(T u) {
                if constexpr(sizeof(T) == 1) {
                    return u;
                } else
#if CE_COMPILER_CLANG
                    if constexpr(std::is_same_v<T, UInt16> || std::is_same_v<T, Int16>) {
                    return __builtin_bswap16(u);
                } else if constexpr(std::is_same_v<T, UInt32> || std::is_same_v<T, Int32>) {
                    return __builtin_bswap32(u);
                } else if constexpr(std::is_same_v<T, UInt64> || std::is_same_v<T, Int64>) {
                    return __builtin_bswap64(u);
                } else
#elif CE_COMPILER_MSVC
                    if constexpr(std::is_same_v<T, UInt16> || std::is_same_v<T, Int16>) {
                    return _byteswap_ushort(u);
                } else if constexpr(std::is_same_v<T, UInt32> || std::is_same_v<T, Int32>) {
                    return _byteswap_ulong(u);
                } else if constexpr(std::is_same_v<T, UInt64> || std::is_same_v<T, Int64>) {
                    return _byteswap_uint64(u);
                } else
#endif
                {
                    static_assert(sizeof(Byte) == 1);
 
                    union {
                        T u;
                        Byte u8[sizeof(T)];
                    } source, destination;
 
                    source.u = u;
                    for(size_t k = 0; k < sizeof(T); k++) {
                        destination.u8[k] = source.u8[sizeof(T) - k - 1];
                    }
 
                    return destination.u;
                }
            }
        };
 
        template<typename T> struct ByteSwapper<Endian::Native, T> {
            T operator()(T u) { return u; }
        };
    } // namespace impl
 
    template<Endian E, typename T>
    requires(std::is_trivially_copyable_v<T>) [[nodiscard]] T byteswap(T u) { return impl::ByteSwapper<E, T>{}(u); }
 
} // namespace CeresEngine