Method next

src/async/asyncIterator.ts:30–63

Fetch the next result from the iterator.

(callback?: (err, result) => void)

    /** Fetch the next result from the iterator. */
    next(callback?: (err, result) => void) {

        // Configure the run context.
        if (this._acceptsCallback) {
            this._runContext.callback = callback; // May be null, in which case it won't be used.
        }
        if (this._returnValue !== Config.NONE) {
            var resolver = defer();
            this._runContext.resolver = resolver;
        }

        // Remove concurrency restrictions for nested calls, to avoid race conditions.
        if (FiberMgr.isExecutingInFiber()) this._semaphore = Semaphore.unlimited;

        // Run the fiber until it either yields a value or completes. For thunks, this is a lazy operation.
        if (this._returnValue === Config.THUNK) {
            var thunk: types.Thunk<any> = (done?) => {
                if (done) resolver.promise.then(val => done(null, val), err => done(err));
                this._semaphore.enter(() => this._fiber.run(this._runContext));
                this._runContext.done = () => this._semaphore.leave();
            };
        } else {
            this._semaphore.enter(() => this._fiber.run(this._runContext));
            this._runContext.done = () => this._semaphore.leave();
        }

        // Return the appropriate value.
        switch (this._returnValue) {
            case Config.PROMISE:    return resolver.promise;
            case Config.THUNK:      return thunk;
            case Config.RESULT:     return await (resolver.promise);
            case Config.NONE:       return;
        }
    }

    /** Enumerate the entire iterator, calling callback with each result. */
    forEach(callback: (value) => void, doneCallback?: (err?) => void): any {