@Override
public MethodRegistry.Compiled compile(
Implementation.Target.Factory implementationTargetFactory) {
Map<Handler, Handler.Compiled> compilationCache =
new HashMap<Handler, Handler.Compiled>(implementations.size());
Map<MethodAttributeAppender.Factory, MethodAttributeAppender> attributeAppenderCache =
new HashMap<MethodAttributeAppender.Factory, MethodAttributeAppender>(
implementations.size());
LinkedHashMap<MethodDescription, Compiled.Entry> entries =
new LinkedHashMap<MethodDescription, Compiled.Entry>(implementations.size());
Implementation.Target implementationTarget =
implementationTargetFactory.make(instrumentedType, methodGraph);
for (Map.Entry<MethodDescription, Entry> entry : implementations.entrySet()) {
Handler.Compiled cachedHandler = compilationCache.get(entry.getValue().getHandler());
if (cachedHandler == null) {
cachedHandler = entry.getValue().getHandler().compile(implementationTarget);
compilationCache.put(entry.getValue().getHandler(), cachedHandler);
}
MethodAttributeAppender cachedAttributeAppender =
attributeAppenderCache.get(entry.getValue().getAppenderFactory());
if (cachedAttributeAppender == null) {
cachedAttributeAppender = entry.getValue().getAppenderFactory().make(instrumentedType);
attributeAppenderCache.put(
entry.getValue().getAppenderFactory(), cachedAttributeAppender);
}
entries.put(
entry.getKey(),
new Compiled.Entry(
cachedHandler,
cachedAttributeAppender,
entry.getValue().getMethodDescription(),
entry.getValue().resolveBridgeTypes()));
}
return new Compiled(instrumentedType, loadedTypeInitializer, typeInitializer, entries);
}
