private List<?> mapListToList(Object srcObj, Collection<?> srcCollectionValue, FieldMap fieldMap, Object destObj, MappingContext context) { return addOrUpdateToList(srcObj, fieldMap, srcCollectionValue, destObj, context); }
private Object mapArrayToArray(Object srcObj, Object srcCollectionValue, FieldMap fieldMap, Object destObj, Class<?> destEntryType, MappingContext context) { // Class destEntryType = fieldMap.getDestFieldType(destObj.getClass()).getComponentType(); int size = Array.getLength(srcCollectionValue); if (CollectionUtils.isPrimitiveArray(srcCollectionValue.getClass())) { return addToPrimitiveArray(srcObj, fieldMap, size, srcCollectionValue, destObj, destEntryType, context); } else { List<?> list = Arrays.asList((Object[]) srcCollectionValue); List<?> returnList; if (!BASE_CLASS.equals(destEntryType.getName())) { returnList = addOrUpdateToList(srcObj, fieldMap, list, destObj, destEntryType, context); } else { returnList = addOrUpdateToList(srcObj, fieldMap, list, destObj, null, context); } return CollectionUtils.convertListToArray(returnList, (Class) destEntryType); } }
private List<String> mapParentFields(ClassMap classMap, Object srcObj, Object destObj, String mapId, MappingContext context) { Collection<ClassMap> superMappings = new ArrayList<ClassMap>(); List<String> mappedParentFields = new ArrayList<String>(); Collection<ClassMap> superClasses = checkForSuperTypeMapping(srcObj.getClass(), destObj.getClass()); superMappings.addAll(superClasses); List<String> overridedFieldMappings = getFieldMapKeys(destObj, classMap.getFieldMaps(), mapId); if (!superMappings.isEmpty()) { mappedParentFields = processSuperTypeMapping(superMappings, srcObj, destObj, mapId, context, overridedFieldMappings); } return mappedParentFields; }
public <T> T map(final Object srcObj, final Class<T> destClass) { return map(srcObj, destClass, (T) null, getContextOrNewEmptyContext(null)); }
result = mapArrayToArray(srcObj, srcCollectionValue, fieldMap, destObj); result = mapArrayToList(srcObj, srcCollectionValue, fieldMap, destObj); result = mapListToArray(srcObj, (List<?>) srcCollectionValue, fieldMap, destObj); result = mapSetToArray(srcObj, (Set<?>) srcCollectionValue, fieldMap, destObj); result = addToSet(srcObj, fieldMap, Arrays.asList((Object[]) srcCollectionValue), destObj); result = addToSet(srcObj, fieldMap, (Collection<?>) srcCollectionValue, destObj); result = mapListToList(srcObj, (List<?>) srcCollectionValue, fieldMap, destObj); result = mapListToList(srcObj, (Collection<?>) srcCollectionValue, fieldMap, destObj);
FieldMappingCondition conditionInstance = conditionObjectsWithId.get(fieldMapping.getMappingConditionId()); Object existingValue = getExistingValue(fieldMapping, srcFieldClass, srcFieldValue, destObj, destFieldType, context); mapField = evaluateConditionInstance(conditionInstance, srcFieldClass, srcFieldValue, destFieldType, existingValue, context); } else { throw new MappingException( Class<?> conditionClass = MappingUtils.loadClass(fieldMapping.getMappingCondition()); Object existingValue = getExistingValue(fieldMapping, srcFieldClass, srcFieldValue, destObj, destFieldType, context); mapField = evaluateCondition(conditionClass, srcFieldClass, srcFieldValue, destFieldType, existingValue, fieldMapping, context); CustomConverter converterInstance = customConverterObjectsWithId.get(fieldMapping .getCustomConverterId()); destFieldValue = mapUsingCustomConverterInstance(converterInstance, srcFieldClass, srcFieldValue, destFieldType, destObj, fieldMapping, context, false); } else { MappingUtils.throwMappingException("Custom converter should be provided"); destFieldValue = mapOrRecurseObject(srcObj, srcFieldValue, destFieldType, destObj, fieldMapping, context); } else { Class<?> srcFieldClass = srcFieldValue != null ? srcFieldValue.getClass() : fieldMapping destFieldValue = mapUsingCustomConverter(converterClass, srcFieldClass, srcFieldValue, destFieldType, destObj, fieldMapping, context, false); writeDestinationValue(destObj, destFieldValue, fieldMapping, srcObj, destDefaultValue);
classMap = getClassMap(srcObj.getClass(), destObj.getClass(), mapId); classMap.getCustomConverters(), srcClass, destClass); if (converter != null) { mapUsingCustomConverterInstance(converter, srcClass, srcObj, destClass, destObj, null, context, true); return; mappedParentFields = mapParentFields(classMap, srcObj, destObj, mapId, context); Collection<FieldMap> fieldMappings = getFieldMappings(classMap, mapId); updateFullFieldMapInfo(fieldMapping); mapField(fieldMapping, srcObj, destObj, context);
classMap = getClassMap(srcObj.getClass(), destObj.getClass(), mapId); destClass); if (converterClass != null) { mapUsingCustomConverter(converterClass, srcClass, srcObj, destClass, destObj, null, true); return; Collection<ClassMap> superMappings = new ArrayList<ClassMap>(); Collection<ClassMap> superClasses = checkForSuperTypeMapping(srcClass, destClass); processSuperTypeMapping(superMappings, srcObj, destObj, mappedParentFields, mapId); continue; mapField(fieldMapping, srcObj, destObj);
result = prepareDestinationList(srcCollectionValue, field); destValue = srcValue; } else { destValue = mapOrRecurseObject(srcObj, srcValue, destEntryType, destObj, fieldMap, context); if ((usesCollectionItemDiscriminator(fieldMap) || RelationshipType.NON_CUMULATIVE.equals(fieldMap.getRelationshipType())) && result.contains(destValue)) { map(null, srcValue, obj, false, null, context); mappedElements.add(obj); removeOrphans(mappedElements, result);
Object result = getExistingValue(fieldMap, srcFieldType, srcFieldValue, destObj, destFieldType, context); ClassMap classMap = null; classMap = getClassMap(srcFieldValue.getClass(), targetClass, mapId); if (canGetNewMapId(srcFieldValue, destObj, context, fieldMap)) { String newMapId = getMapId(srcFieldValue, destObj, context, fieldMap); context.setMapId(newMapId); map(classMap, srcFieldValue, result, false, getMapId(context), context); context.setMapId(oldMapId);
classMap = getClassMap(srcObj.getClass(), destType, getMapId(context)); return (T) mapUsingCustomConverterInstance(converter, srcObj.getClass(), srcObj, destType, result, null, context, true); map(classMap, srcObj, result, false, getMapId(context), context); } catch (Throwable e) { MappingUtils.throwMappingException(e);
value = mapUsingCustomConverterInstance(converter, srcFieldClass, value, fieldMapping .getDestHintContainer().getHint(), null, fieldMapping, context, false); } else { value = alreadyMappedValue; } else { value = map(value, fieldMapping.getDestHintContainer().getHint()); writeDestinationValue(destObj, value, fieldMapping, srcObj, null);
destValue = srcValue; } else { destValue = mapOrRecurseObject(srcObj, srcValue, destEntryType, destObj, fieldMap, context); if ((usesCollectionItemDiscriminator(fieldMap) || RelationshipType.NON_CUMULATIVE.equals(fieldMap.getRelationshipType())) && result.contains(destValue)) { List<Object> resultAsList = new ArrayList<Object>(result); int index = resultAsList.indexOf(destValue); map(null, srcValue, obj, false, null, context); mappedElements.add(obj);
private Object mapArrayToArray(Object srcObj, Object srcCollectionValue, FieldMap fieldMap, Object destObj) { Class destEntryType = fieldMap.getDestFieldType(destObj.getClass()).getComponentType(); Class srcEntryType = srcCollectionValue.getClass().getComponentType(); int size = Array.getLength(srcCollectionValue); CopyByReferenceContainer copyByReferences = globalConfiguration.getCopyByReferences(); boolean isPrimitiveArray = CollectionUtils.isPrimitiveArray(srcCollectionValue.getClass()); boolean isFinal = Modifier.isFinal(srcEntryType.getModifiers()); boolean isCopyByReference = copyByReferences.contains(srcEntryType); if (destEntryType.isAssignableFrom(srcEntryType) && isFinal && (isPrimitiveArray || isCopyByReference)) { return addArrayContentCopy(fieldMap, size, srcCollectionValue, destObj, destEntryType); } else if (isPrimitiveArray) { return addToPrimitiveArray(srcObj, fieldMap, size, srcCollectionValue, destObj, destEntryType); } else { List<?> list = Arrays.asList((Object[]) srcCollectionValue); List<?> returnList; if (!destEntryType.getName().equals(BASE_CLASS)) { returnList = addOrUpdateToList(srcObj, fieldMap, list, destObj, destEntryType); } else { returnList = addOrUpdateToList(srcObj, fieldMap, list, destObj, null); } return CollectionUtils.convertListToArray(returnList, destEntryType); } }
result = getExistingValue(fieldMap, destObj, destFieldType); targetClass = destFieldType; ClassMap classMap = getClassMap(srcFieldValue.getClass(), targetClass, mapId); fieldMap.getDestFieldCreateMethod() != null ? fieldMap.getDestFieldCreateMethod() : classMap.getDestClassCreateMethod()); result = createByCreationDirectiveAndMap(creationDirective, classMap, srcFieldValue, null, false, fieldMap.getMapId()); } else { mapToDestObject(null, srcFieldValue, result, false, fieldMap.getMapId());
private Object mapMap(Object srcObj, Map srcMapValue, FieldMap fieldMap, Object destObj, MappingContext context) { Map result; Map destinationMap = (Map) fieldMap.getDestValue(destObj); if (destinationMap == null) { result = DestBeanCreator.create(context.getParams(), srcMapValue.getClass()); } else { result = destinationMap; if (fieldMap.isRemoveOrphans()) { result.clear(); } } for (Entry<?, Object> srcEntry : ((Map<?, Object>) srcMapValue).entrySet()) { Object srcEntryValue = srcEntry.getValue(); if (srcEntryValue == null) { // overwrites with null in any case result.put(srcEntry.getKey(), null); continue; } Object destEntryValue = mapOrRecurseObject(srcObj, srcEntryValue, srcEntryValue.getClass(), destObj, fieldMap, context); Object obj = result.get(srcEntry.getKey()); if (obj != null && obj.equals(destEntryValue) && fieldMap.isNonCumulativeRelationship()) { map(null, srcEntryValue, obj, false, null, context); } else { result.put(srcEntry.getKey(), destEntryValue); } } return result; }
classMap = getClassMap(srcObj.getClass(), destType, mapId); return (T) mapUsingCustomConverter(converterClass, srcObj.getClass(), srcObj, destType, result, null, true); classMap.getDestClassBeanFactory(), classMap.getDestClassBeanFactoryId(), classMap.getDestClassCreateMethod()); result = createByCreationDirectiveAndMap(creationDirective, classMap, srcObj, result, false, null); } catch (Throwable e) { MappingUtils.throwMappingException(e);
/** * Maps classes using mappings of super classes. * * @param superClasses mappings of super classes * @param srcObj source * @param destObj destination * @param mapId map id * @param context user parameters * @param overriddenFieldMappings overridden field mappings * @return list of mapped field keys */ private List<String> processSuperTypeMapping(Collection<ClassMap> superClasses, Object srcObj, Object destObj, String mapId, MappingContext context, List<String> overriddenFieldMappings) { List<String> mappedFieldKeys = new ArrayList<String>(); for (ClassMap map : superClasses) { // create copy of super class map which will be modified farther ClassMap copy = map.copyOf(); // remove from field mappings list entries that overridden by child // class removeOverriddenFieldMappings(copy, overriddenFieldMappings, destObj); // map classes using field mappings for super classes map(copy, srcObj, destObj, true, mapId, context); for (FieldMap fieldMapping : copy.getFieldMaps()) { // remember mapped fields String key = MappingUtils.getMappedParentFieldKey(destObj, fieldMapping); mappedFieldKeys.add(key); } } return mappedFieldKeys; }
public <T> T map(final Object srcObj, final Class<T> destClass) { return map(srcObj, destClass, null); }
protected Mapper getMappingProcessor() { initMappings(); Mapper processor = new MappingProcessor(customMappings, globalConfiguration, cacheManager, statsMgr, customConverters, eventManager, getCustomFieldMapper(), customConvertersWithId); // If statistics are enabled, then Proxy the processor with a statistics interceptor if (statsMgr.isStatisticsEnabled()) { processor = (Mapper) Proxy.newProxyInstance(processor.getClass().getClassLoader(), processor.getClass().getInterfaces(), new StatisticsInterceptor(processor, statsMgr)); } return processor; }