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 clear separation of concerns: main conversion logic, capability checks, key/value conversion helpers, and a small entry holder class. Nesting is minimal and flow is mostly linear. Intent is clear from method names and Javadoc comments. Action granularity is appropriate, generally one or two logical operations per line. The main convert method has a slightly long sequence of steps and a non-obvious 'copyRequired' flag that requires careful reading, but the shortcut comments help. Minor redundancy exists in MapEntry for simple put operations, but it aids readability. Overall, the code reads naturally and would be easy to maintain.
Run 3
The code is well-structured and readable. It follows a logical organization with clear separation between conversion logic, helper methods, and an internal data holder. Nesting is minimal, with only one level of loop and a few early returns. Method names clearly convey intent (e.g., canConvertKey, convertValue). The main convert method is concise without unnecessary repetition. Action granularity is mostly one action per line, especially in the loop. Reading flow is natural: null checks, shortcut checks, element conversion, map creation, and population. Javadoc and comments aid understanding. Minor deductions include the slightly verbose MapEntry helper and some repetitive null-check patterns, but overall it is highly maintainable.
Run 1
Code Structure: Well organized into public conversion 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 communicate map conversion; reference-identity checks and deferred copying require slightly more thought. Code length: Mostly concise, though parallel key/value helpers and the entry holder add some boilerplate. Action granularity: Statements generally perform one action per line, making conversion steps easy to follow. Reading flow: Natural progression from validation and shortcuts to element conversion and target-map construction. The intermediate entry list introduces a second processing phase, but its role in avoiding unnecessary map copying is understandable.
Run 2
Code Structure: Well organized into interface methods, focused conversion 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 deferred map creation require some thought. Code length: Mostly concise, although parallel key/value helpers and the MapEntry wrapper introduce modest repetition and overhead. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Conversion proceeds naturally from null handling through entry conversion to optional map creation; the intermediate entry list and copyRequired optimization slightly complicate an otherwise straightforward sequence.
Run 3
Code Structure: Well organized into converter methods, focused helpers, and a small entry holder. Nesting: Shallow conditionals and loops, with early returns keeping control flow simple. Clarity of intent: Descriptive names and class documentation clearly explain map conversion; identity comparisons and copyRequired optimization require some thought. Code length: Mostly concise, although parallel key/value helpers and the intermediate MapEntry list add modest verbosity. Action granularity: Statements generally perform one clear action per line. Reading flow: Natural progression from null handling through element conversion to optional map creation, with helpers separated cleanly. The two-pass conversion strategy slightly increases the effort needed to follow the main method.