public List<FieldMappingMetadata> getFieldMappings() { List<FieldMappingMetadata> fieldMapCats = new ArrayList<FieldMappingMetadata>(); for(FieldMap fieldMap : classMap.getFieldMaps()) { fieldMapCats.add(new DozerFieldMappingMetadata(fieldMap)); } return fieldMapCats; }
private void processSuperTypeMapping(Collection<ClassMap> superClasses, Object srcObj, Object destObj, List<String> mappedParentFields, String mapId) { for (ClassMap map : superClasses) { map(map, srcObj, destObj, true, mappedParentFields ,mapId); for (FieldMap fieldMapping : map.getFieldMaps()) { String key = MappingUtils.getMappedParentFieldKey(destObj, fieldMapping); mappedParentFields.add(key); } } }
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; }
private Collection<FieldMap> getGeneralFieldMaps(ClassMap classMap) { // If map id is not specified get field mapping which are defined without // mapId value. Map<String, FieldMap> mappings = new LinkedHashMap<String, FieldMap>(); for (FieldMap fieldMapping : classMap.getFieldMaps()) { String key = MappingUtils.fieldMapKey(fieldMapping); if (MappingUtils.isBlankOrNull(fieldMapping.getMapId())) { mappings.put(key, fieldMapping); } } return mappings.values(); }
/** * Removes field maps from class map what are overridden. * * @param copy copy of class map * @param overriddenFieldMappings keys of overridden field mappings * @param destObj destination object */ private void removeOverriddenFieldMappings(ClassMap copy, List<String> overriddenFieldMappings, Object destObj) { List<FieldMap> result = new ArrayList<FieldMap>(); for (FieldMap fieldMap : copy.getFieldMaps()) { String key = MappingUtils.getMappedParentFieldKey(destObj, fieldMap); if (!overriddenFieldMappings.contains(key)) { result.add(fieldMap); } } copy.setFieldMaps(result); }
/** * Removes field maps from class map what are overridden. * * @param copy copy of class map * @param overriddenFieldMappings keys of overridden field mappings * @param destObj destination object */ private void removeOverriddenFieldMappings(ClassMap copy, List<String> overriddenFieldMappings, Object destObj) { List<FieldMap> result = new ArrayList<FieldMap>(); for (FieldMap fieldMap : copy.getFieldMaps()) { String key = MappingUtils.getMappedParentFieldKey(destObj, fieldMap); if (!overriddenFieldMappings.contains(key)) { result.add(fieldMap); } } copy.setFieldMaps(result); }
private Collection<FieldMap> getGeneralFieldMaps(ClassMap classMap) { // If map id is not specified get field mapping which are defined // without // mapId value. Map<String, FieldMap> mappings = new LinkedHashMap<String, FieldMap>(); for (FieldMap fieldMapping : classMap.getFieldMaps()) { String key = MappingUtils.fieldMapKey(fieldMapping); if (MappingUtils.isBlankOrNull(fieldMapping.getMapId())) { mappings.put(key, fieldMapping); } } return mappings.values(); }
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; }
private Collection<FieldMap> getMapIdSpecificFieldMaps(ClassMap classMap, String mapId) { Map<String, FieldMap> mappings = new LinkedHashMap<String, FieldMap>(); // In case when map id is provided by user we should get field // mappings which are defined with same mapId value and // field mappings which are defined without mapId value as default // mappings if appropriate mappings are not found. for (FieldMap fieldMapping : classMap.getFieldMaps()) { // If field mapping has different mapId value we just ignore it. if (!MappingUtils.isBlankOrNull(fieldMapping.getMapId()) && !mapId.equals(fieldMapping.getMapId())) { continue; } String key = MappingUtils.fieldMapKey(fieldMapping); // Check that field mapping with same key is already contained // in map. If it's true we should check that a field mapping // which represented by fieldMapping parameter is more // applicable than existing one. If it's true we remove existing // field mapping from map; otherwise - skip the rest of method. if (mappings.containsKey(key) && !MappingUtils.isBlankOrNull(mappings.get(key).getMapId()) && MappingUtils.isBlankOrNull(fieldMapping.getMapId())) { continue; } mappings.put(key, fieldMapping); } return mappings.values(); }
/** * 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; }
private Collection<FieldMap> getMapIdSpecificFieldMaps(ClassMap classMap, String mapId) { Map<String, FieldMap> mappings = new LinkedHashMap<String, FieldMap>(); // In case when map id is provided by user we should get field // mappings which are defined with same mapId value and // field mappings which are defined without mapId value as default // mappings if appropriate mappings are not found. for (FieldMap fieldMapping : classMap.getFieldMaps()) { // If field mapping has different mapId value we just ignore it. if (!MappingUtils.isBlankOrNull(fieldMapping.getMapId()) && !mapId.equals(fieldMapping.getMapId())) { continue; } String key = MappingUtils.fieldMapKey(fieldMapping); // Check that field mapping with same key is already contained // in map. If it's true we should check that a field mapping // which represented by fieldMapping parameter is more // applicable than existing one. If it's true we remove existing // field mapping from map; otherwise - skip the rest of method. if (mappings.containsKey(key) && !MappingUtils.isBlankOrNull(mappings.get(key).getMapId()) && MappingUtils .isBlankOrNull(fieldMapping.getMapId())) { continue; } mappings.put(key, fieldMapping); } return mappings.values(); }
for (FieldMap fieldMapping : copy.getFieldMaps()) {
for (FieldMap fieldMapping : classMap.getFieldMaps()) {
if (classMap.getFieldMaps() != null) { Object[] fms = classMap.getFieldMaps().toArray();
if (classMap.getFieldMaps() != null) { Object[] fms = classMap.getFieldMaps().toArray();
MappingUtils.reverseFields(classMap, classMapPrime); if (classMap.getFieldMaps() != null) { List<FieldMap> fms = classMap.getFieldMaps();