String.h

Go to the documentation of this file.

#pragma once
 
#include <limits>
#include <map>
#include <optional>
#include <random>
#include <set>
#include <string>
 
#include "faker-cxx/Export.h"
#include "RandomGenerator.h"
#include "types/Hex.h"
 
namespace faker::string
{
enum class StringCasing
{
    Mixed,
    Lower,
    Upper
};
 
struct FAKER_CXX_EXPORT CharCount
{
    unsigned int atLeastCount{(std::numeric_limits<unsigned int>::min)()};
    unsigned int atMostCount{(std::numeric_limits<unsigned int>::max)()};
};
 
using GuaranteeMap = std::map<char, CharCount>;
 
FAKER_CXX_EXPORT bool isValidGuarantee(GuaranteeMap& guarantee, std::set<char>& targetCharacters, unsigned int length);
 
FAKER_CXX_EXPORT std::string generateAtLeastString(const GuaranteeMap& guarantee);
 
    // namespace {
    //     std::string generateStringWithGuarantee(GuaranteeMap& guarantee, std::set<char>& targetCharacters,
    //                                                unsigned int length);
    // }
    template <typename T = std::mt19937>
    std::string uuid(RandomGenerator<T> gen = RandomGenerator<std::mt19937>{})
    {
        static std::uniform_int_distribution<> dist(0, 15);
        static std::uniform_int_distribution<> dist2(8, 11);
        static std::string_view hexCharacters{"0123456789abcdef"};
 
        std::string result;
        result.reserve(36);
 
        for (int i = 0; i < 8; i++)
        {
            result.append(1, hexCharacters[static_cast<size_t>(gen(dist))]);
        }
        result.append(1, '-');
 
        for (int i = 0; i < 4; i++)
        {
            result.append(1, hexCharacters[static_cast<size_t>(gen(dist))]);
        }
        result.append(1, '-');
 
        result.append(1, '4');
        for (int i = 0; i < 3; i++)
        {
            result.append(1, hexCharacters[static_cast<size_t>(gen(dist))]);
        }
        result.append(1, '-');
 
        result.append(1, hexCharacters[static_cast<size_t>(gen(dist2))]);
 
        for (int i = 0; i < 3; i++)
        {
            result.append(1, hexCharacters[static_cast<size_t>(gen(dist))]);
        }
        result.append(1, '-');
 
        for (int i = 0; i < 12; i++)
        {
            result.append(1, hexCharacters[static_cast<size_t>(gen(dist))]);
        }
 
        return result;
    }
 
    FAKER_CXX_EXPORT std::string sample(unsigned length = 10);
 
    FAKER_CXX_EXPORT std::string sample(GuaranteeMap&& guarantee, unsigned length = 10);
 
    FAKER_CXX_EXPORT std::string fromCharacters(const std::string& characters, unsigned length = 1);
 
    FAKER_CXX_EXPORT std::string fromCharacters(GuaranteeMap&& guarantee, const std::string& characters, unsigned length = 1);
 
    FAKER_CXX_EXPORT std::string alpha(unsigned length = 1, StringCasing casing = StringCasing::Mixed,
                             const std::string& excludeCharacters = "");
 
    FAKER_CXX_EXPORT std::string alpha(GuaranteeMap&& guarantee, unsigned length = 1, StringCasing casing = StringCasing::Mixed);
 
    FAKER_CXX_EXPORT std::string alphanumeric(unsigned length = 1, StringCasing casing = StringCasing::Mixed,
                                    const std::string& excludeCharacters = "");
 
    FAKER_CXX_EXPORT std::string alphanumeric(GuaranteeMap&& guarantee, unsigned length = 1,
                                    StringCasing casing = StringCasing::Mixed);
 
    FAKER_CXX_EXPORT std::string numeric(unsigned length = 1, bool allowLeadingZeros = true);
 
    FAKER_CXX_EXPORT std::string numeric(GuaranteeMap&& guarantee, unsigned length = 1, bool allowLeadingZeros = true);
 
    FAKER_CXX_EXPORT std::string hexadecimal(unsigned length = 1, HexCasing casing = HexCasing::Lower,
                                   HexPrefix prefix = HexPrefix::ZeroX);
 
    FAKER_CXX_EXPORT std::string hexadecimal(std::optional<int> min = std::nullopt, std::optional<int> max = std::nullopt);
 
    FAKER_CXX_EXPORT std::string hexadecimal(GuaranteeMap&& guarantee, unsigned length = 1, HexCasing casing = HexCasing::Lower,
                                   HexPrefix prefix = HexPrefix::ZeroX);
 
    FAKER_CXX_EXPORT std::string binary(unsigned length = 1);
 
    FAKER_CXX_EXPORT std::string binary(GuaranteeMap&& guarantee, unsigned length = 1);
 
    FAKER_CXX_EXPORT std::string octal(unsigned length = 1);
 
    FAKER_CXX_EXPORT std::string octal(GuaranteeMap&& guarantee, unsigned length = 1);
}