How to use

ClassMappings

in

org.dozer.classmap

private ClassMap getClassMap(Class<?> srcClass, Class<?> destClass, String mapId) {
 ClassMap mapping = classMappings.find(srcClass, destClass, mapId);
 if (mapping == null) {
  // If mapping not found in existing custom mapping collection, create
  // default as an explicit mapping must not
  // exist. The create default class map method will also add all default
  // mappings that it can determine.
  mapping = ClassMapBuilder.createDefaultClassMap(globalConfiguration, srcClass, destClass);
  classMappings.addDefault(srcClass, destClass, mapping);
 }
 return mapping;
}

public void addAll(ClassMappings additionalClassMappings) {
  Map<String, ClassMap> newMappings = additionalClassMappings.getAll();
  for (Entry<String, ClassMap> entry : newMappings.entrySet()) {
    ClassMap result = classMappings.put(entry.getKey(), entry.getValue());
    failOnDuplicate(result, entry.getValue());
  }
}

 throw new IllegalArgumentException("Global configuration parameter cannot be null");
ClassMappings result = new ClassMappings();
if (classMaps == null || classMaps.size() == 0) {
 return result;
 result.add(classMap.getSrcClassToMap(), classMap.getDestClassToMap(), classMap.getMapId(), classMap);
  result.add(classMap.getDestClassToMap(), classMap.getSrcClassToMap(), classMap.getMapId(), classMapPrime);

ClassMappings customMappings = new ClassMappings();
 customMappings.addAll(customMappingsPrime);
for (Entry<String, ClassMap> entry : customMappings.getAll().entrySet()) {
 ClassMap classMap = entry.getValue();
 if (classMap.getCustomConverters() != null) {

private void checkForClassMapping(Class<?> srcClass, List<ClassMap> superClasses, Class<?> superDestClass) {
 ClassMap srcClassMap = classMappings.find(srcClass, superDestClass);
 if (srcClassMap != null) {
  superClasses.add(srcClassMap);
 }
}

private ClassMap findInterfaceMapping(Class<?> destClass, Class<?> srcClass, String mapId) {
 // Use object array for keys to avoid any rare thread synchronization issues
 // while iterating over the custom mappings.
 // See bug #1550275.
 Object[] keys = classMappings.keySet().toArray();
 for (Object key : keys) {
  ClassMap map = classMappings.get(key);
  Class<?> mappingDestClass = map.getDestClassToMap();
  Class<?> mappingSrcClass = map.getSrcClassToMap();
  if ((mapId == null && map.getMapId() != null) || (mapId != null && !mapId.equals(map.getMapId()))) {
   continue;
  }
  if (isInterfaceImplementation(srcClass, mappingSrcClass)) {
   if (isInterfaceImplementation(destClass, mappingDestClass)) {
    return map;
   } else if (destClass.equals(mappingDestClass)) {
    return map;
   }
  }
  // Destination could be an abstract type. Picking up the best concrete type to use.
  if ((destClass.isAssignableFrom(mappingDestClass) && isAbstract(destClass)) ||
      (isInterfaceImplementation(destClass, mappingDestClass))) {
   if (MappingUtils.getRealClass(srcClass).equals(mappingSrcClass)) {
    return map;
   }
  }
 }
 return null;
}

public List<ClassMappingMetadata> getClassMappings() {
  List<ClassMappingMetadata> classMapMetadata = new ArrayList<ClassMappingMetadata>();
  
  for(ClassMap classMap : classMappings.getAll().values()) {
    classMapMetadata.add(new DozerClassMappingMetadata(classMap));
  }
  return classMapMetadata;
}

public void add(Class<?> srcClass, Class<?> destClass, String mapId, ClassMap classMap) {
 ClassMap result = classMappings.put(keyFactory.createKey(srcClass, destClass, mapId), classMap);
 failOnDuplicate(result, classMap);
}

public ClassMap find(Class<?> srcClass, Class<?> destClass, String mapId) {
 final String key = keyFactory.createKey(srcClass, destClass, mapId);
 ClassMap mapping = classMappings.get(key);
 if (mapping == null) {
  mapping = findInterfaceMapping(destClass, srcClass, mapId);
 }
 // one more try...
 // if the mapId is not null looking up a map is easy
 if (!MappingUtils.isBlankOrNull(mapId) && mapping == null) {
  // probably a more efficient way to do this...
  for (Entry<String, ClassMap> entry : classMappings.entrySet()) {
   ClassMap classMap = entry.getValue();
   if (StringUtils.equals(classMap.getMapId(), mapId)
       && classMap.getSrcClassToMap().isAssignableFrom(srcClass)
       && classMap.getDestClassToMap().isAssignableFrom(destClass)) {
    return classMap;
   } else if (StringUtils.equals(classMap.getMapId(), mapId) && srcClass.equals(destClass)) {
    return classMap;
   }
  }
  // If map-id was specified and mapping was not found, then fail
  MappingUtils.throwMappingException("Class mapping not found by map-id: " + key);
 }
 return mapping;
}

  throw new IllegalArgumentException("Global configuration parameter cannot be null");
ClassMappings result = new ClassMappings();
if (classMaps == null || classMaps.size() == 0) {
  return result;
  result.add(classMap.getSrcClassToMap(), classMap.getDestClassToMap(), classMap.getMapId(), classMap);
    result.add(classMap.getDestClassToMap(), classMap.getSrcClassToMap(), classMap.getMapId(),
      classMapPrime);

ClassMappings customMappings = new ClassMappings();
  List<ClassMap> classMaps = mappingFileData.getClassMaps();
  ClassMappings customMappingsPrime = mappingsParser.processMappings(classMaps, globalConfiguration);
  customMappings.addAll(customMappingsPrime);
for (Entry<String, ClassMap> entry : customMappings.getAll().entrySet()) {
  ClassMap classMap = entry.getValue();
  if (classMap.getCustomConverters() != null) {

private void checkForClassMapping(Class<?> srcClass, List<ClassMap> superClasses, Class<?> superDestClass) {
  ClassMap srcClassMap = classMappings.find(srcClass, superDestClass);
  if (srcClassMap != null) {
    superClasses.add(srcClassMap);
  }
}

if (isInterfaceImplementation(srcClass, mappingSrcClass)) {
  if (isInterfaceImplementation(destClass, mappingDestClass)) {
    return map;
  } else if (destClass.equals(mappingDestClass)) {
if ((destClass.isAssignableFrom(mappingDestClass) && isAbstract(destClass)) || (isInterfaceImplementation(
  destClass, mappingDestClass))) {
  if (MappingUtils.getRealClass(srcClass).equals(mappingSrcClass)) {

/**
 * Prepares default mappings based on provided mapping definition
 *
 * @param classMappings
 * @param globalConfiguration
 */
public static void addDefaultFieldMappings(ClassMappings classMappings, Configuration globalConfiguration) {
 Set<Entry<String, ClassMap>> entries = classMappings.getAll().entrySet();
 for (Entry<String, ClassMap> entry : entries) {
  ClassMap classMap = entry.getValue();
  generateMapping(classMap, globalConfiguration, runTimeGenerators);
 }
}

public void add(Class<?> srcClass, Class<?> destClass, ClassMap classMap) {
 ClassMap result = classMappings.put(keyFactory.createKey(srcClass, destClass), classMap);
 failOnDuplicate(result, classMap);
}

public ClassMap find(Class<?> srcClass, Class<?> destClass, String mapId) {
  final String key = keyFactory.createKey(srcClass, destClass, mapId);
  ClassMap mapping = classMappings.get(key);
  if (mapping == null) {
    mapping = findInterfaceMapping(destClass, srcClass, mapId);
  }
  // one more try...
  // if the mapId is not null looking up a map is easy
  if (!MappingUtils.isBlankOrNull(mapId) && mapping == null) {
    // probably a more efficient way to do this...
    for (Entry<String, ClassMap> entry : classMappings.entrySet()) {
      ClassMap classMap = entry.getValue();
      if (StringUtils.equals(classMap.getMapId(), mapId) && classMap.getSrcClassToMap()
        .isAssignableFrom(srcClass) && classMap.getDestClassToMap().isAssignableFrom(destClass)) {
        return classMap;
      } else if (StringUtils.equals(classMap.getMapId(), mapId) && srcClass.equals(destClass)) {
        return classMap;
      }
    }
    // If map-id was specified and mapping was not found, then fail
    MappingUtils.throwMappingException("Class mapping not found by map-id: " + key);
  }
  return mapping;
}

  mapping = classMappings.find(srcClass, destClass, mapId);
} catch (Exception e) {
  if (log.isDebugEnabled()) {
  mapping = classMappings.find(srcClass, destClass);
  classMappings.addDefault(srcClass, destClass, mapping);

  throw new IllegalArgumentException("Global configuration parameter cannot be null");
ClassMappings result = new ClassMappings();
if (classMaps == null || classMaps.size() == 0) {
  return result;
  result.add(classMap.getSrcClassToMap(), classMap.getDestClassToMap(), classMap.getMapId(), classMap);
    result.add(classMap.getDestClassToMap(),
      classMap.getSrcClassToMap(),
      classMap.getMapId(),

private void checkForClassMapping(Class<?> srcClass, List<ClassMap> superClasses, Class<?> superDestClass) {
  ClassMap srcClassMap = classMappings.find(srcClass, superDestClass);
  if (srcClassMap != null) {
    superClasses.add(srcClassMap);
  }
}

public void addAll(ClassMappings additionalClassMappings) {
 Map<String, ClassMap> newMappings = additionalClassMappings.getAll();
 for (Entry<String, ClassMap> entry : newMappings.entrySet()) {
  ClassMap result = classMappings.put(entry.getKey(), entry.getValue());
  failOnDuplicate(result, entry.getValue());
 }
}