main.cpp

#include "BaseProduct.h"
#include "ProductWithID.h"
#include "ConcreteProductA.h"
#include "ConcreteProductB.h"
#include "TempProduct.h"
#include "ProductTypes.h" 
#include "ThreadPool.h"
#include "Factory.h"
#include <vector>
#include <tuple>
#include <memory>
#include <string>
#include <atomic>
#include <iostream>
#include <variant>
#include <span>
#include <future>
#include <stop_token>

import LOGGER;

using std::cout;
using std::endl;
// Determine the number of threads based on the hardware capabilities
const unsigned int numThreads = std::thread::hardware_concurrency();
// Function to extract IDs from a span of ProductVariant
std::vector<int> extractID(std::span<const ProductVariant> products) {
    std::vector<int> vecID;
    for (const auto& p : products) {
        std::visit([&vecID](const auto& product) {
            using T = std::decay_t<decltype(product)>;
            if constexpr (std::is_base_of_v<ProductWithID, T>) {
                vecID.push_back(product.getID());
            }
        }, p); 
    }
    return vecID;
}
// Function to process all products using the provided thread pool
void processProducts(ThreadPool& pool, const std::vector<ProductVariant>& products) {
    std::vector<std::future<void>> futures;

    for (const auto& product : products) {
        futures.push_back(pool.enqueue([product]() {
            std::visit([](const auto& p) {
                p.process();
                }, product);
            }));
    }
    // Wait for all process tasks to complete
    for (auto& future : futures) {
        future.get(); // Ensure all tasks have finished
    }
}
// Function to extract IDs from products using the provided thread pool
void extractProductIDs(ThreadPool& pool, const std::vector<ProductVariant>& products, std::vector<int>& allIds) {
    const size_t numChunks = 2; // Adjust as needed -- Number of chunks to divide the product list into
    std::vector<std::future<std::vector<int>>> futures;
    size_t chunkSize = products.size() / numChunks;
    // Split products into chunks and submit tasks to extract IDs
    for (size_t i = 0; i < numChunks; ++i) {
        size_t start = i * chunkSize;
        size_t end = (i == numChunks - 1) ? products.size() : start + chunkSize;

        // Create a span for the current chunk of products
        std::span<const ProductVariant> productSpan(products.data() + start, end - start);

        // Submit the extraction task to the thread pool
        futures.push_back(pool.enqueue([productSpan]() {
            return extractID(productSpan);
            }));
    }
    // Collect results from all extraction tasks
    for (auto& future : futures) {
        std::vector<int> ids = future.get();
        allIds.insert(allIds.end(), ids.begin(), ids.end());
    }
}

int main() {
    ThreadPool poolProcess(numThreads); // Create a thread pool for processing products
    ThreadPool poolExtraction(numThreads); // Create a thread pool for extracting IDs
    // Prepare a list of products
    // Prepare a list of products using the factory
    Factory<int, std::string> factoryA;
    Factory<int, int> factoryB;
    Factory<> factoryTemp;

    std::vector<ProductVariant> products;

    // Create products using the factory
    auto [productA1, index1, name1] = factoryA.creatProduct(1, 0, "ProductA1");
    auto [productB1, id1, other1] = factoryB.creatProduct(2, 42);
    auto [tempProduct] = factoryTemp.creatProduct();

    // Add products to the vector
    products.push_back(std::move(productA1));
    products.push_back(std::move(productB1));
    products.push_back(std::move(tempProduct));

    // Add more products if needed
    auto [productA2, index2, name2] = factoryA.creatProduct(3, 1, "ProductA2");
    auto [productB2, id2, other2] = factoryB.creatProduct(4, 84);

    products.push_back(std::move(productA2));
    products.push_back(std::move(productB2));

    // Process products
    processProducts(poolProcess, products);

    // Extract IDs from all products
    std::vector<int> allIds;
    extractProductIDs(poolExtraction, products, allIds);

    // Print all extracted IDs
    INFO("ID Extracted: ");
    for (int id : allIds) {
        cout << id << endl; // Output each ID to the console
    }

    return 0;
}