1import java.util.concurrent.CompletableFuture;
2import java.util.concurrent.ExecutionException;
3import java.util.function.Supplier;
4import java.util.List;
5import java.util.ArrayList;
6
7// Java does not have type unions like TypeScript, so we use an interface with subclasses for fulfilled and rejected promise outcomes.
8interface ResultObj {}
9class FulfilledObj implements ResultObj {
10    String status;
11    Object value;
12  
13    public FulfilledObj(Object value) {
14        this.status = "fulfilled";
15        this.value = value;
16    }
17}
18class RejectedObj implements ResultObj {
19    String status;
20    Object reason;
21  
22    public RejectedObj(Object reason) {
23        this.status = "rejected";
24        this.reason = reason;
25    }
26}
27
28public class PromiseAllSettled {
29
30    // Function that simulates Promise.allSettled for an array of suppliers that return CompletableFuture.
31    // It returns a CompletableFuture that resolves to a list of objects indicating the outcome of each CompletableFuture.
32    public static CompletableFuture<List<ResultObj>> promiseAllSettled(List<Supplier<CompletableFuture<Object>>> suppliers) {
33        // List to hold the outcomes of each CompletableFuture.
34        List<CompletableFuture<ResultObj>> futures = new ArrayList<>();
35    
36        // Convert each supplier to a CompletableFuture and handle its resolution accordingly.
37        for (Supplier<CompletableFuture<Object>> supplier : suppliers) {
38            CompletableFuture<ResultObj> future = supplier.get()
39                    .thenApply(value -> new FulfilledObj(value))
40                    .exceptionally(ex -> new RejectedObj(ex));
41            futures.add(future);
42        }
43    
44        // Combine all CompletableFuture instances into a single CompletableFuture that will be resolved when all are completed.
45        CompletableFuture<Void> allDoneFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
46    
47        // Return a CompletableFuture that resolves to a list of ResultObj instances representing the outcome of each.
48        return allDoneFuture.thenApply(v -> {
49            List<ResultObj> results = new ArrayList<>();
50            futures.forEach(f -> {
51                try {
52                    results.add(f.get());
53                } catch (InterruptedException | ExecutionException e) {
54                    // This should never happen since we're calling get after all futures are done.
55                    throw new RuntimeException(e);
56                }
57            });
58            return results;
59        });
60    }
61
62    // Example usage of the `promiseAllSettled` function.
63    public static void main(String[] args) throws ExecutionException, InterruptedException {
64        List<Supplier<CompletableFuture<Object>>> suppliers = new ArrayList<>();
65        suppliers.add(() -> CompletableFuture.supplyAsync(() -> {
66            // Simulate a task that takes some time to complete
67            try {
68                Thread.sleep(100);
69            } catch (InterruptedException e) {
70                e.printStackTrace();
71            }
72            return "Result";
73        }));
74
75        CompletableFuture<List<ResultObj>> promise = promiseAllSettled(suppliers);
76
77        // Start timing
78        long startTime = System.currentTimeMillis();
79
80        // When all CompletableFutures are settled, print the outcome.
81        promise.thenAccept(res -> {
82            long elapsedTime = System.currentTimeMillis() - startTime;
83            System.out.println("Elapsed time: " + elapsedTime + "ms");
84            for (ResultObj obj : res) {
85                if (obj instanceof FulfilledObj) {
86                    FulfilledObj fulfilled = (FulfilledObj) obj;
87                    System.out.println("Status: " + fulfilled.status + ", Value: " + fulfilled.value.toString());
88                } else if (obj instanceof RejectedObj) {
89                    RejectedObj rejected = (RejectedObj) obj;
90                    System.out.println("Status: " + rejected.status + ", Reason: " + rejected.reason.toString());
91                }
92            }
93        }).get(); // Waiting for completion to ensure that the results are printed out.
94    }
95}
96

1#include <future>
2#include <vector>
3#include <functional>
4#include <iostream>
5#include <chrono>
6
7// Define C++ equivalent types for both fulfilled and rejected future outcomes.
8struct FulfilledObj {
9    std::string status = "fulfilled";
10    std::shared_ptr<void> value; // Using shared_ptr for type-erased generic value
11};
12
13struct RejectedObj {
14    std::string status = "rejected";
15    std::string reason; // Assuming the reason will be string for simplicity
16};
17
18// Union-like structure that can hold either outcome.
19struct OutcomeObj {
20    std::string status;
21    std::shared_ptr<void> value; // For 'fulfilled'
22    std::string reason;          // For 'rejected'
23};
24
25// Function that simulates Promise.allSettled for an array of functions that return futures.
26// This function will return a future that resolves to a vector of OutcomeObj, representing each promise's outcome.
27std::future<std::vector<OutcomeObj>> promiseAllSettled(
28    const std::vector<std::function<std::future<void>()>>& functions) {
29
30    return std::async(std::launch::async, [functions]{
31        std::vector<OutcomeObj> outcomes;
32        // Reserve space for outcome objects based on the number of input functions.
33        outcomes.reserve(functions.size());
34      
35        // Iterate through the function array and execute each function.
36        for (const auto& func : functions) {
37            // Attempt to fulfill the future and handle the outcome accordingly.
38            try {
39                // Wait for the future to complete and store a FulfilledObj.
40                std::shared_ptr<void> result = func().get();
41                outcomes.push_back(OutcomeObj{"fulfilled", result, ""});
42            }
43            catch (const std::exception& e) {
44                // If an exception is thrown, store a RejectedObj.
45                outcomes.push_back(OutcomeObj{"rejected", nullptr, e.what()});
46            }
47        }
48      
49        // All futures are settled at this point, return the outcomes.
50        return outcomes;
51    });
52}
53
54// Example usage of the `promiseAllSettled` function.
55int main() {
56    // Create a vector of functions that return futures.
57    std::vector<std::function<std::future<void>()>> functions = {
58        // Example function that fulfills the future after a delay.
59        [] {
60            return std::async(std::launch::async, [] {
61                std::this_thread::sleep_for(std::chrono::milliseconds(100));
62                // In this example, return type is void. Type erasure can be done to hold any type.
63                return;
64            });
65        }
66    };
67
68    // Record start time.
69    auto startTime = std::chrono::high_resolution_clock::now();
70
71    // Call `promiseAllSettled` and wait for all futures to settle.
72    auto outcomesFuture = promiseAllSettled(functions);
73    outcomesFuture.wait(); // Wait for all futures to complete.
74  
75    // Calculate the elapsed time.
76    auto endTime = std::chrono::high_resolution_clock::now();
77    auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
78
79    // Retrieve the outcomes and print the results.
80    std::vector<OutcomeObj> outcomes = outcomesFuture.get();
81    for (const auto& outcome : outcomes) {
82        if (outcome.status == "fulfilled") {
83            std::cout << "{\"status\":\"" << outcome.status << "\",\"value\":\"Result\"}" << std::endl;
84        } else {
85            std::cout << "{\"status\":\"" << outcome.status << "\",\"reason\":\"" << outcome.reason << "\"}" << std::endl;
86        }
87    }
88
89    std::cout << "Elapsed Time: " << elapsedTime << "ms\n";
90    return 0;
91}
92

1// Define TypeScript types for both fulfilled and rejected promise outcomes.
2type FulfilledObj = {
3    status: 'fulfilled';
4    value: unknown;
5};
6type RejectedObj = {
7    status: 'rejected';
8    reason: unknown;
9};
10type Obj = FulfilledObj | RejectedObj;
11
12// Function that simulates Promise.allSettled for an array of functions that return promises.
13// It returns a Promise that resolves to an array of objects indicating the outcome of each promise.
14function promiseAllSettled(functions: (() => Promise<unknown>)[]): Promise<Obj[]> {
15    return new Promise(resolve => {
16        // Array to hold the outcomes of each promise.
17        const results: Obj[] = [];
18        // Counter to keep track of resolved promises.
19        let completedCount = 0;
20
21        // Iterate through the function array and execute each function.
22        functions.forEach((func, index) => {
23            // Assume that each function returns a promise and handle its resolution accordingly.
24            func()
25                .then(value => ({ status: 'fulfilled', value } as FulfilledObj))
26                .catch(reason => ({ status: 'rejected', reason } as RejectedObj))
27                .then(obj => {
28                    // When a promise is settled (either fulfilled or rejected), store its result.
29                    results[index] = obj;
30                    // Increment the number of completed promises.
31                    completedCount++;
32                    // When all promises have been settled, resolve the outer promise with the results array.
33                    if (completedCount === functions.length) {
34                        resolve(results);
35                    }
36                });
37        });
38    });
39}
40
41// Example usage of the `promiseAllSettled` function.
42// Uncomment the following code to test the functionality.
43/*
44const functions = [
45   () => new Promise(resolve => setTimeout(() => resolve('Result'), 100))
46];
47const startTime = performance.now();
48
49const promise = promiseAllSettled(functions);
50
51promise.then(res => {
52    const elapsedTime = Math.floor(performance.now() - startTime);
53    const output = { elapsed: elapsedTime, values: res };
54    console.log(output); // Expected output: {"elapsed":100,"values":[{"status":"fulfilled","value":"Result"}]}
55});
56*/
57