Source code
package org.springframework.core.convert.support;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jspecify.annotations.Nullable;
import org.springframework.core.CollectionFactory;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.convert.converter.ConditionalGenericConverter;
/**
* Converts a Map to another Map.
*
* <p>First, creates a new Map of the requested targetType with a size equal to the
* size of the source Map. Then copies each element in the source map to the target map.
* Will perform a conversion from the source map's parameterized K,V types to the target
* map's parameterized types K,V if necessary.
*
* @author Keith Donald
* @author Juergen Hoeller
* @since 3.0
*/
final class MapToMapConverter implements ConditionalGenericConverter {
private final ConversionService conversionService;
public MapToMapConverter(ConversionService conversionService) {
this.conversionService = conversionService;
}
@Override
public Set<ConvertiblePair> getConvertibleTypes() {
return Collections.singleton(new ConvertiblePair(Map.class, Map.class));
}
@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
return canConvertKey(sourceType, targetType) && canConvertValue(sourceType, targetType);
}
@Override
public @Nullable Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (source == null) {
return null;
}
@SuppressWarnings("unchecked")
Map<Object, Object> sourceMap = (Map<Object, Object>) source;
// Shortcut if possible...
boolean copyRequired = !targetType.getType().isInstance(source);
if (!copyRequired && sourceMap.isEmpty()) {
return sourceMap;
}
TypeDescriptor keyDesc = targetType.getMapKeyTypeDescriptor();
TypeDescriptor valueDesc = targetType.getMapValueTypeDescriptor();
List<MapEntry> targetEntries = new ArrayList<>(sourceMap.size());
for (Map.Entry<Object, Object> entry : sourceMap.entrySet()) {
Object sourceKey = entry.getKey();
Object sourceValue = entry.getValue();
Object targetKey = convertKey(sourceKey, sourceType, keyDesc);
Object targetValue = convertValue(sourceValue, sourceType, valueDesc);
targetEntries.add(new MapEntry(targetKey, targetValue));
if (sourceKey != targetKey || sourceValue != targetValue) {
copyRequired = true;
}
}
if (!copyRequired) {
return sourceMap;
}
Map<Object, Object> targetMap = CollectionFactory.createMap(targetType.getType(),
(keyDesc != null ? keyDesc.getType() : null), sourceMap.size());
for (MapEntry entry : targetEntries) {
entry.addToMap(targetMap);
}
return targetMap;
}
// internal helpers
private boolean canConvertKey(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getMapKeyTypeDescriptor(),
targetType.getMapKeyTypeDescriptor(), this.conversionService);
}
private boolean canConvertValue(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getMapValueTypeDescriptor(),
targetType.getMapValueTypeDescriptor(), this.conversionService);
}
private @Nullable Object convertKey(Object sourceKey, TypeDescriptor sourceType, @Nullable TypeDescriptor targetType) {
if (targetType == null) {
return sourceKey;
}
return this.conversionService.convert(sourceKey, sourceType.getMapKeyTypeDescriptor(sourceKey), targetType);
}
private @Nullable Object convertValue(Object sourceValue, TypeDescriptor sourceType, @Nullable TypeDescriptor targetType) {
if (targetType == null) {
return sourceValue;
}
return this.conversionService.convert(sourceValue, sourceType.getMapValueTypeDescriptor(sourceValue), targetType);
}
private static class MapEntry {
private final @Nullable Object key;
private final @Nullable Object value;
public MapEntry(@Nullable Object key, @Nullable Object value) {
this.key = key;
this.value = value;
}
public void addToMap(Map<Object, Object> map) {
map.put(this.key, this.value);
}
}
}
Run 1
The code is highly readable with clear structure and intent. It follows a logical organization: constructor, interface methods, main conversion logic, helper methods, and an inner class. Nesting is shallow, with only one level inside the loop and conditionals. Action granularity is appropriate, with mostly one action per line. Reading flow is natural, guiding the reader from type checks through conversion to map creation. The use of helper methods (canConvertKey, convertKey, etc.) improves clarity and reduces duplication. The 'Shortcut if possible...' comment clarifies the early return. Minor deductions: the convert method is somewhat long but still coherent, and the MapEntry inner class adds slight overhead but is well-encapsulated. Overall, the code is concise, well-documented, and easy to follow.
Run 2
The code is well-structured, with a clear class name, logical method organization, and helpful comments. Nesting is minimal (one loop, simple conditionals), making the flow easy to follow. Intent is evident throughout, especially through method names like canConvertKey, convertValue, and the MapEntry helper. Length is appropriate — concise without sacrificing clarity. Each line performs a single action, enhancing readability. The reading flow is natural, progressing from validation to conversion to result creation. Minor deductions for the slightly verbose MapEntry class and repeated pattern in convertKey/convertValue, but overall very readable.
Run 3
The code is well-structured with clear separation of concerns: type checking, conversion, and helper methods. Nesting is minimal, with only one level in the main loop and early returns reducing complexity. Intent is clearly expressed through descriptive method names and a helpful class-level comment. The code is concise—helper methods avoid duplication and keep the main conversion method focused. Action granularity is appropriate, with one logical operation per line. Reading flow is natural: edge cases first, then processing, then map construction. Minor deductions: the MapEntry inner class adds slight indirection for simple key-value storage, and the use of nullability annotations, while beneficial, adds visual noise. Overall, this is highly readable production-quality code.
Run 1
Code Structure: Well organized into interface methods, focused conversion helpers, and a small entry holder. Nesting: Shallow loops and conditionals, with early returns keeping complexity low. Clarity of intent: Descriptive names and class documentation clearly communicate map conversion; reference comparisons and deferred map creation require slightly more thought. Code length: Reasonably concise, although parallel key/value helpers and the MapEntry class add modest verbosity. Action granularity: Statements generally perform one action per line, making conversion steps easy to follow. Reading flow: Natural progression from null handling and shortcut checks through element conversion to target-map construction. Consistent formatting supports scanning, though some long signatures and extra blank lines slightly reduce compactness.
Run 2
Code Structure: Well organized into conversion logic, focused helper methods, and a small entry class. Nesting: Shallow conditionals and loops, with early returns keeping control flow flat. Clarity of intent: Descriptive names and class documentation clearly explain map conversion; reference-identity comparisons and deferred copying require slightly more thought. Code length: Generally concise, though separate key/value helpers and the intermediate MapEntry class add some boilerplate. Action granularity: Statements mostly perform one action per line, making individual operations easy to follow. Reading flow: Natural progression from null handling and shortcut checks through element conversion to target-map creation; the two-pass conversion strategy adds modest cognitive overhead.
Run 3
Code Structure: Well organized into converter methods, focused helpers, and a small entry holder. Nesting: Shallow loops and conditionals, with early returns keeping control flow flat. Clarity of intent: Descriptive names and class documentation clearly explain map conversion; identity comparisons and copyRequired require some thought to understand the reuse optimization. Code length: Mostly concise, though parallel key/value helpers and the intermediate MapEntry class add modest verbosity. Action granularity: Statements generally perform one action per line; longer conversion calls remain understandable. Reading flow: Natural progression from validation through element conversion to map creation, with consistent formatting. The two-pass approach slightly interrupts the flow, and a comment explaining deferred allocation would improve readability.