Brunobkr/llama.cpp_AlgMor24_github

1'use strict';2 3Object.defineProperty(exports, "__esModule", {4    value: true5});6exports.default = parallel;7 8var _eachOf = require('./eachOf.js');9 10var _eachOf2 = _interopRequireDefault(_eachOf);11 12var _parallel2 = require('./internal/parallel.js');13 14var _parallel3 = _interopRequireDefault(_parallel2);15 16function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }17 18/**19 * Run the `tasks` collection of functions in parallel, without waiting until20 * the previous function has completed. If any of the functions pass an error to21 * its callback, the main `callback` is immediately called with the value of the22 * error. Once the `tasks` have completed, the results are passed to the final23 * `callback` as an array.24 *25 * **Note:** `parallel` is about kicking-off I/O tasks in parallel, not about26 * parallel execution of code.  If your tasks do not use any timers or perform27 * any I/O, they will actually be executed in series.  Any synchronous setup28 * sections for each task will happen one after the other.  JavaScript remains29 * single-threaded.30 *31 * **Hint:** Use [`reflect`]{@link module:Utils.reflect} to continue the32 * execution of other tasks when a task fails.33 *34 * It is also possible to use an object instead of an array. Each property will35 * be run as a function and the results will be passed to the final `callback`36 * as an object instead of an array. This can be a more readable way of handling37 * results from {@link async.parallel}.38 *39 * @name parallel40 * @static41 * @memberOf module:ControlFlow42 * @method43 * @category Control Flow44 * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection of45 * [async functions]{@link AsyncFunction} to run.46 * Each async function can complete with any number of optional `result` values.47 * @param {Function} [callback] - An optional callback to run once all the48 * functions have completed successfully. This function gets a results array49 * (or object) containing all the result arguments passed to the task callbacks.50 * Invoked with (err, results).51 * @returns {Promise} a promise, if a callback is not passed52 *53 * @example54 *55 * //Using Callbacks56 * async.parallel([57 *     function(callback) {58 *         setTimeout(function() {59 *             callback(null, 'one');60 *         }, 200);61 *     },62 *     function(callback) {63 *         setTimeout(function() {64 *             callback(null, 'two');65 *         }, 100);66 *     }67 * ], function(err, results) {68 *     console.log(results);69 *     // results is equal to ['one','two'] even though70 *     // the second function had a shorter timeout.71 * });72 *73 * // an example using an object instead of an array74 * async.parallel({75 *     one: function(callback) {76 *         setTimeout(function() {77 *             callback(null, 1);78 *         }, 200);79 *     },80 *     two: function(callback) {81 *         setTimeout(function() {82 *             callback(null, 2);83 *         }, 100);84 *     }85 * }, function(err, results) {86 *     console.log(results);87 *     // results is equal to: { one: 1, two: 2 }88 * });89 *90 * //Using Promises91 * async.parallel([92 *     function(callback) {93 *         setTimeout(function() {94 *             callback(null, 'one');95 *         }, 200);96 *     },97 *     function(callback) {98 *         setTimeout(function() {99 *             callback(null, 'two');100 *         }, 100);101 *     }102 * ]).then(results => {103 *     console.log(results);104 *     // results is equal to ['one','two'] even though105 *     // the second function had a shorter timeout.106 * }).catch(err => {107 *     console.log(err);108 * });109 *110 * // an example using an object instead of an array111 * async.parallel({112 *     one: function(callback) {113 *         setTimeout(function() {114 *             callback(null, 1);115 *         }, 200);116 *     },117 *     two: function(callback) {118 *         setTimeout(function() {119 *             callback(null, 2);120 *         }, 100);121 *     }122 * }).then(results => {123 *     console.log(results);124 *     // results is equal to: { one: 1, two: 2 }125 * }).catch(err => {126 *     console.log(err);127 * });128 *129 * //Using async/await130 * async () => {131 *     try {132 *         let results = await async.parallel([133 *             function(callback) {134 *                 setTimeout(function() {135 *                     callback(null, 'one');136 *                 }, 200);137 *             },138 *             function(callback) {139 *                 setTimeout(function() {140 *                     callback(null, 'two');141 *                 }, 100);142 *             }143 *         ]);144 *         console.log(results);145 *         // results is equal to ['one','two'] even though146 *         // the second function had a shorter timeout.147 *     }148 *     catch (err) {149 *         console.log(err);150 *     }151 * }152 *153 * // an example using an object instead of an array154 * async () => {155 *     try {156 *         let results = await async.parallel({157 *             one: function(callback) {158 *                 setTimeout(function() {159 *                     callback(null, 1);160 *                 }, 200);161 *             },162 *            two: function(callback) {163 *                 setTimeout(function() {164 *                     callback(null, 2);165 *                 }, 100);166 *            }167 *         });168 *         console.log(results);169 *         // results is equal to: { one: 1, two: 2 }170 *     }171 *     catch (err) {172 *         console.log(err);173 *     }174 * }175 *176 */177function parallel(tasks, callback) {178    return (0, _parallel3.default)(_eachOf2.default, tasks, callback);179}180module.exports = exports.default;