The default implementation will simply call {@link AsyncMapping#map(Object, Promise)} but
users can override this method to implement custom behavior.

@see AsyncMapping#map(Object, Promise)
510142
@Override
    protected Future<SslContext> lookup(ChannelHandlerContext ctx, String hostname) throws Exception {
        return mapping.map(hostname, ctx.executor().<SslContext>newPromise());
    }
13889
public Future<PutObjectResult> putAsync(String key, String value) {
        return Future.of(() -> put(key, value), this.uploadService)
                      .flatMap(t->t.fold(p->Future.ofResult(p),e->Future.ofError(e)));
    }
986363
public void setApplicationMap(final Map<String, Object> applicationMap) {
		JKThreadLocal.setValue(JKContextConstants.APPLICATION_MAP, applicationMap);
	}
573371
function map(callable, children) {
  var iterator = (0, _cmap.default)(callable, children)[Symbol.asyncIterator]();
  return new _Children.default(iterator, undefined);
}
209221
@Nonnull
  protected MapAppender createMapDumper(@Nonnull OutputStream outputStream, @Nonnull RecordCache recordCache) {
    return new JacksonMapAppender(outputStream, recordCache);
  }
1238814
function(map, callback) {

            // Walk through all modules in parallel
            async.map(map, function(module, callback) {

                // Filter all non-js files in parallel
                async.filter(
                    pathHelper.list(module.path),
                function(path, callback) {
                    callback(path.match(/\.js$/i));
                }, function(paths) {
                    module.paths = paths;
                    callback(null, module);
                });

            }, callback);
        }
987896
@Override
    public Builder claim(Map<String, Object> map) throws InvalidClaimException {
        if (map == null) {
            String err = Tr.formatMessage(tc, "JWT_INVALID_CLAIMS_ERR");// "JWT_INVALID_CLAIMS_ERR";
            throw new InvalidClaimException(err);
        }
        return copyClaimsMap(map);
        // claims.putAll(map);
        // return this;
    }
758396
function statusCode(map) {
                var code = undefined;
                if (map) {
                    if (state < 2) {
                        for (code in map) {
                            // Lazy-add the new callback in a way that preserves old ones
                            _statusCode[code] = [_statusCode[code], map[code]];
                        }
                    } else {
                        // Execute the appropriate callbacks
                        jqXHR.always(map[jqXHR.status]);
                    }
                }
                return this;
            }
738225
public void setTypeMap(Map<Class<? extends T>, C> map) {
		this.classified = new ConcurrentHashMap<Class<? extends T>, C>(map);
	}
1194053
@Override
    public YourFuture async(ConcurrentAsyncCall noArgLambda) {
        assertThreadCallbackNotNull(noArgLambda);
        assertExecutorServiceValid();
        if (noArgLambda.asPrimary()) { // forcing option
            return doAsyncPrimary(noArgLambda);
        } else {
            final ConcurrentAsyncImportance importance = noArgLambda.importance();
            if (importance != null) {
                if (ConcurrentAsyncImportance.PRIMARY.equals(importance)) {
                    return doAsyncPrimary(noArgLambda);
                } else if (ConcurrentAsyncImportance.SECONDARY.equals(importance)) {
                    return doAsyncSecondary(noArgLambda);
                } else if (ConcurrentAsyncImportance.TERTIARY.equals(importance)) {
                    return doAsyncTertiary(noArgLambda);
                } else { // no way
                    throw new IllegalStateException("Unknown importance: " + importance);
                }
            } else {
                return doAsyncSecondary(noArgLambda); // as default
            }
        }
    }
875997
public <R> Future<R> map(final Function<? super T, ? extends R> fn, Executor ex) {
        return new Future<R>(
                              future.thenApplyAsync(fn,ex));
    }
357661
public static Map<String, Object> newMap(String key, Object value) {
        final Map<String, Object> result = newMap();
        result.put(key, value);
        return result;
    }
803394
function( map ) {
					var code;
					if ( map ) {
						if ( completed ) {

							// Execute the appropriate callbacks
							jqXHR.always( map[ jqXHR.status ] );
						} else {

							// Lazy-add the new callbacks in a way that preserves old ones
							for ( code in map ) {
								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
							}
						}
					}
					return this;
				}
56251
public static <K, V> Map<K, V> createLinkedHashMap(int expectedMapSize) {
        final int initialCapacity = calculateInitialCapacity(expectedMapSize);
        return new LinkedHashMap<K, V>(initialCapacity, HASHMAP_DEFAULT_LOAD_FACTOR);
    }
844379
function (keyOrMap, value) {
				if (typeof keyOrMap === typeObj) {
					for (var key in keyOrMap) {
						if (hasOwn.call(keyOrMap, key)) {
							set(nucleus, key, keyOrMap[key]);
						}
					}
				} else {
					set(nucleus, keyOrMap, value);
				}
				return me;
			}
1195964
static Map<String, Object> valueAsMap(Map<String, Object> map, Key key, Map<String, Object> defaultValue) {
        if (map.containsKey(key.key)) {
            Object rawOrMap = map.get(key.key);
            if (rawOrMap instanceof Map) {
                @SuppressWarnings("unchecked")
                Map<String, Object> submap = (Map<String, Object>) rawOrMap;
                return submap;
            } else {
                return defaultValue;
            }
        }
        return defaultValue;
    }
390873
public void setMap(Map<String, Object> map) {
        eventMap.clear();
        eventMap.putAll(map);
    }