generator.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "core/argvec2.hpp"
#include "core/core.hpp"
#include "core/source.hpp"
#include "generatorsettings.hpp"
 
namespace lipsum
{

    enum GeneratorFlags : bool
    {
        USELIPSUM    = true,
        NO_USELIPSUM = false,
        HTML         = true,
        MARKDOWN     = false,
        OBJECT       = true,
        ARRAY        = false,
        BOLD         = true,
        ITALIC       = false,
        ORDERED      = true,
        UNORDERED    = false,
        IPV4         = false,
        IPV6         = true,
        NOPORT       = false,
        PORT         = true
    };

    enum class CaseSlugCase : int
    {
        CamelCase = 0,
        PascalCase,
        SnakeCase,
        ShoutyCase,
        KebabCase,
        TrainCase,
    };

    enum class CodeLanguage : int
    {
        Cpp = 0,
        Python,
        Rust,
        C,
        JavaScript
    };

    class LIPSUM_API Generator
    {
    public:
        Generator();

        Generator(int seed);

        Generator(const std::string& path, int seed);

        ~Generator();

        Generator(const std::string& path);

        void load_source(const std::string& path);

        void load_seed(int seed);

        void change_setting(const std::string& setting, const ArgVec2& value);

        void
        change_setting(const std::string& setting, int minValue, int maxValue);

        void toggle_lazy();
 
        /*
         * CORE
         */

        std::string word(int num = 1);

        std::string fragment();

        std::string sentence(int num = 1, bool useLipsum = true);

        std::string paragraph(int num = 1, bool useLipsum = true);

        std::string text(bool useLipsum = true);
 
        /*
         * MISC
         */

        std::string
        scramble(int length = 16, char minChar = ' ', char maxChar = '~');

        std::string url();

        std::string plain_url();

        std::string email();

        std::string slug(char separator = '-');

        std::string case_slug(CaseSlugCase case_ = CaseSlugCase::CamelCase);

        std::string code(CodeLanguage lang = CodeLanguage::Cpp);

        std::string ip_addr(bool useIpv6 = false, bool usePort = false);

        std::string phone_number();
 
        /*
         * FORMATS
         */

        std::string
        fmt_paragraph(int num = 1, bool useLipsum = true, bool useHtml = false);

        std::string fmt_text(int numElements = 15, bool useHtml = false);

        std::string fmt_header(int level = 1, bool useHtml = false);

        std::string fmt_emphasis(bool isBold = true, bool useHtml = false);

        std::string fmt_link(bool useHtml = false);

        std::string fmt_list(bool ordered = false, bool useHtml = false);

        std::string xml(int choices = 30);

        std::string json(int maxDepth = 3, bool isObject = true);

        std::string json_value(int maxDepth = 3);

        std::string csv();
 
    private:
        std::string single_sentence(const ArgVec2& wordArg,
                                    const ArgVec2& frag);

        std::string single_paragraph(bool useLipsum);

        std::string single_fmt_paragraph(bool useLipsum, bool useHtml);

        std::string json_string();

        std::string json_number();

        template <internal::UniformDistributionType T>
        T random_number(T min, T max)
        {
            if (min > max)
            {
                T tempMax = max;
                max       = min;
                min       = tempMax;
            }
            if constexpr (std::is_integral_v<T>)
            {
                std::uniform_int_distribution<T> dist(min, max);
                return dist(m_Gen);
            }
            else
            {
                std::uniform_real_distribution<T> dist(min, max);
                return dist(m_Gen);
            }
        }

        char random_number(char min, char max);

        bool random_number(bool min, bool max);

        int weighted_random_idx(const std::vector<int>& weights);

        std::string tld();
 
        GeneratorSettings m_Settings; 
 
        std::mt19937 m_Gen; 

        Source m_Source;
    };
} // namespace lipsum