congrats Icon
New! Announcing our next generation AI code completions
Read here
Tabnine Logo
ClassMappings
Code IndexAdd Tabnine to your IDE (free)

How to use
ClassMappings
in
org.dozer.classmap

Best Java code snippets using org.dozer.classmap.ClassMappings (Showing top 20 results out of 315)

origin: net.sf.dozer/dozer

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;
}
origin: org.openl.rules/org.openl.rules.mapping.dev.dozer

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());
  }
}
origin: net.sf.dozer/dozer

 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);
origin: net.sf.dozer/dozer

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

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

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;
}
origin: net.sf.dozer/dozer

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

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

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;
}
origin: org.openl.rules/org.openl.rules.mapping.dev.modified

  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);
origin: org.openl.rules/org.openl.rules.mapping.dev.dozer

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) {
origin: org.openl.rules/org.openl.rules.mapping.dev.dozer

private void checkForClassMapping(Class<?> srcClass, List<ClassMap> superClasses, Class<?> superDestClass) {
  ClassMap srcClassMap = classMappings.find(srcClass, superDestClass);
  if (srcClassMap != null) {
    superClasses.add(srcClassMap);
  }
}
origin: org.openl.rules/org.openl.rules.mapping.dev.dozer

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)) {
origin: net.sf.dozer/dozer

/**
 * 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);
 }
}
origin: net.sf.dozer/dozer

public void add(Class<?> srcClass, Class<?> destClass, ClassMap classMap) {
 ClassMap result = classMappings.put(keyFactory.createKey(srcClass, destClass), classMap);
 failOnDuplicate(result, classMap);
}
origin: org.openl.rules/org.openl.rules.mapping.dev.dozer

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;
}
origin: org.openl.rules/org.openl.rules.mapping.dev.dozer

  mapping = classMappings.find(srcClass, destClass, mapId);
} catch (Exception e) {
  if (log.isDebugEnabled()) {
  mapping = classMappings.find(srcClass, destClass);
  classMappings.addDefault(srcClass, destClass, mapping);
origin: org.openl.rules/org.openl.rules.mapping.dev.dozer

  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(),
origin: org.openl.rules/org.openl.rules.mapping.dev.modified

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

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());
 }
}
org.dozer.classmapClassMappings

Javadoc

Internal class that determines the appropriate class mapping to be used for the source and destination object being mapped. Only intended for internal use.

Most used methods

  • find
  • <init>
  • add
  • addDefault
  • addAll
  • failOnDuplicate
  • findInterfaceMapping
  • getAll
  • isAbstract
  • isInterfaceImplementation

Popular in Java

  • Parsing JSON documents to java classes using gson
  • compareTo (BigDecimal)
  • getExternalFilesDir (Context)
  • onRequestPermissionsResult (Fragment)
  • FlowLayout (java.awt)
    A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
  • ConnectException (java.net)
    A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
  • BlockingQueue (java.util.concurrent)
    A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
  • JComboBox (javax.swing)
  • JTable (javax.swing)
  • IOUtils (org.apache.commons.io)
    General IO stream manipulation utilities. This class provides static utility methods for input/outpu
  • Top 17 PhpStorm Plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now