The Dream Master

#include <iostream>
#include <vector>
#include <string>
#include <bitset>

// random include
#include <random>
#include "random/pcg_random.hpp"
#include "random/pcg_extras.hpp"

class james_dean_data_component {
    protected:

        signed long long int local_system_id = 0;
        signed long long int local_data_id = 0;
        signed long long int local_type_id = 0;
        signed long long int local_class_id = 0;

        std::vector<signed long long int> local_random_vector;
        std::vector<signed long long int> local_mod_vector;

        void set_local_system_id(signed long long int system_id_input)
        {
            local_system_id = system_id_input;
        }

        void set_local_data_id(signed long long int data_id_input)
        {
            local_data_id = data_id_input;
        }

        void set_local_type_id(signed long long int type_id_input)
        {
            local_type_id = type_id_input;
        }

        void set_local_class_id(signed long long int class_id_input)
        {
            local_class_id = class_id_input;
        }

        void set_local_random_vector(std::vector<signed long long int> random_vector_input)
        {
            local_random_vector = random_vector_input;
        }

        void set_local_mod_vector(std::vector<signed long long int> mod_vector_input)
        {
            local_mod_vector = mod_vector_input;
        }

    public:

        void call_set_local_system_id(signed long long int system_input_int)
        {
            set_local_system_id(system_input_int);
        }

        void call_set_local_data_id(signed long long int data_input_int)
        {
            set_local_data_id(data_input_int);
        }

        void call_set_local_type_id(signed long long int type_input_int)
        {
            set_local_type_id(type_input_int);
        }

        void call_set_local_class_id(signed long long int class_input_int)
        {
            set_local_class_id(class_input_int);
        }

        void call_set_local_random_vector(std::vector<signed long long int> random_int_input)
        {
            set_local_random_vector(random_int_input);
        }

        void call_set_local_mod_vector(std::vector<signed long long int> mod_int_input)
        {
            set_local_mod_vector(mod_int_input);
        }
};

class james_dean_data : public james_dean_data_component {
    protected:

    public:


};

class earth_citizen {
    protected:

        signed long long int citizen_id = 0;

        std::vector<james_dean_data> data_install;

        void set_data_install(std::vector<james_dean_data> data_install_input)
        {
            data_install = data_install_input;
        }

        void set_citizen_id(signed long long int citizen_id_input)
        {
            citizen_id = citizen_id_input;
        }

    public:

        void call_set_data_install(std::vector<james_dean_data> install_input)
        {
            set_data_install(install_input);
        }

        void call_set_citizen_id(signed long long int citizen_int_input)
        {
            set_citizen_id(citizen_int_input);
        }
};

// FORWARD DECLARATIONS
std::vector<signed long long int> return_random_vector();

// INT MAIN
int main(int argc, char *argv[])
{
    std::cout << "--+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ \n";
    std::cout << "\tMadness Presents...\n\t\t\tThe\n\t\t\t\t\tJames Dean\n\t\t\t\t\t\t\tProgram!\nVersion: 002\tRevision: 01\n";
    std::cout << "--+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ --+ \n";

    bool production = true;

    signed long long int class_id_total = 0;
    signed long long int type_id_total = 0;
    signed long long int data_id_total = 0;

    signed long long int master_data_target = 2'000;

    signed long long int data_id_target = master_data_target / 10;
    signed long long int class_id_target = master_data_target / 40;
    signed long long int type_id_target = master_data_target / 18;

    signed long long int master_data_current = 0;

    signed long long int display_ticker = 0;

    std::vector<james_dean_data> james_dean_vector;

    signed long long int local_system_id = 0;

    std::vector<signed long long int> local_random_vector;
    std::vector<signed long long int> local_mod_vector;

    signed long long int total_random_number = 0;

    signed long long int display_count = 0;

    while (production == true)
    {
        std::cout << "top of production\n";

        for(signed long long int current_class_id = 0; current_class_id < class_id_target; current_class_id++)
        {
            for(signed long long int current_type_id = 0; current_type_id < type_id_target; current_type_id++)
            {
                for(signed long long int current_data_id = 0; current_data_id < data_id_target; current_data_id++)
                {
                    james_dean_data local_james_dean_data;

                    local_james_dean_data.call_set_local_system_id(local_system_id);

                    local_james_dean_data.call_set_local_data_id(current_data_id);
                    local_james_dean_data.call_set_local_type_id(current_type_id);
                    local_james_dean_data.call_set_local_class_id(current_class_id);

                    local_random_vector = return_random_vector();
                    local_mod_vector = return_random_vector();

                    local_james_dean_data.call_set_local_random_vector(local_random_vector);
                    local_james_dean_data.call_set_local_mod_vector(local_mod_vector);

                    total_random_number = total_random_number + 8'000;

                    james_dean_vector.push_back(local_james_dean_data);

                    master_data_current = master_data_current + 1;

                    if(master_data_current >= master_data_target)
                    {
                        production = false;

                        goto production_over;
                    }
                }

                display_ticker = display_ticker + 1;

                if(display_ticker > 99)
                {
                    display_ticker = 0;

                    display_count = display_count + 1;

                    std::cout << "================================================================================\n";

                    std::cout << "class_id_total: " << class_id_total << "\n";
                    std::cout << "type_id_total: " << type_id_total << "\n";
                    std::cout << "data_id_total: " << data_id_total << "\n";
                    std::cout << "\ntotal_random_number = " << total_random_number << "::" << total_random_number / 4'000 << " sets generated" << "\n";

                    std::cout << "\n\n";

                    std::cout << "master_data_target: " << master_data_target << "/" << master_data_current << "\n";

                    std::cout << "\ndisplay_count: " << display_count << "\n";
                }
            }
        }
    }

    // here add all the data that was created to each person on earth...
    production_over:
    signed long long int citizen_id = 0;
    signed long long int total_population = 7'951'000'000;

    while (citizen_id < total_population)
    {
        earth_citizen new_local_citizen;

        new_local_citizen.call_set_citizen_id(citizen_id);
        new_local_citizen.call_set_data_install(james_dean_vector);

        std::cout << "citizen_id: " << citizen_id << "\n";

        citizen_id = citizen_id + 1;
    }

    return(0);
}

// RETURN RANDOM VECTOR
std::vector<signed long long int> return_random_vector()
{
    pcg_extras::seed_seq_from<std::random_device> seed_source;
    pcg64_k1024 pcg64(seed_source);

    signed long long int random_number = 0;

    std::vector<signed long long int> random_number_vector;

    signed long long int number_target = 4'000;

    signed long long int current_int = 0;

    while (current_int < number_target)
    {
        random_number = pcg64();

        random_number_vector.push_back(random_number);

        current_int = current_int + 1;
    }

    return(random_number_vector);
}