public String createKey(Class<?> srcClass, Class<?> destClass, String mapId) { Class<?> srcRealClass = MappingUtils.getRealClass(srcClass); Class<?> destRealClass = MappingUtils.getRealClass(destClass); StringBuilder result = new StringBuilder(140); result.append("SRC-CLASS->"); result.append(srcRealClass.getName()); result.append(" DST-CLASS->"); result.append(destRealClass.getName()); if (StringUtils.isNotEmpty(mapId)) { result.append(" MAP-ID->"); result.append(mapId); } return result.toString(); }
public String createKey(Class<?> srcClass, Class<?> destClass, String mapId) { Class<?> srcRealClass = MappingUtils.getRealClass(srcClass); Class<?> destRealClass = MappingUtils.getRealClass(destClass); StringBuilder result = new StringBuilder(140); result.append("SRC-CLASS->"); result.append(srcRealClass.getName()); result.append(" DST-CLASS->"); result.append(destRealClass.getName()); if (StringUtils.isNotEmpty(mapId)) { result.append(" MAP-ID->"); result.append(mapId); } return result.toString(); }
@SuppressWarnings("unchecked") public static List<Class<?>> getInterfaceHierarchy(Class<?> srcClass) { final List<Class<?>> result = new LinkedList<Class<?>>(); Class<?> realClass = getRealClass(srcClass); final LinkedList<Class> interfacesToProcess = new LinkedList<Class>(); Class[] interfaces = realClass.getInterfaces(); interfacesToProcess.addAll(Arrays.asList(interfaces)); while (!interfacesToProcess.isEmpty()) { Class<?> iface = interfacesToProcess.remove(); if (!result.contains(iface)) { result.add(iface); for (Class subiface : iface.getInterfaces()) { // if we haven't processed this interface yet then add it to // be processed if (!result.contains(subiface)) { interfacesToProcess.add(subiface); } } } } return result; }
@SuppressWarnings("unchecked") public static List<Class<?>> getInterfaceHierarchy(Class<?> srcClass) { final List<Class<?>> result = new LinkedList<Class<?>>(); Class<?> realClass = getRealClass(srcClass); final LinkedList<Class> interfacesToProcess = new LinkedList<Class>(); Class[] interfaces = realClass.getInterfaces(); interfacesToProcess.addAll(Arrays.asList(interfaces)); while (!interfacesToProcess.isEmpty()) { Class<?> iface = interfacesToProcess.remove(); if (!result.contains(iface)) { result.add(iface); for (Class subiface : iface.getInterfaces()) { // if we haven't processed this interface yet then add it to be processed if (!result.contains(subiface)) { interfacesToProcess.add(subiface); } } } } return result; }
@SuppressWarnings("unchecked") public static List<Class<?>> getInterfaceHierarchy(Class<?> srcClass) { final List<Class<?>> result = new LinkedList<Class<?>>(); Class<?> realClass = getRealClass(srcClass); final LinkedList<Class> interfacesToProcess = new LinkedList<Class>(); Class[] interfaces = realClass.getInterfaces(); interfacesToProcess.addAll(Arrays.asList(interfaces)); while (!interfacesToProcess.isEmpty()) { Class<?> iface = interfacesToProcess.remove(); if (!result.contains(iface)) { result.add(iface); for (Class subiface : iface.getInterfaces()) { // if we haven't processed this interface yet then add it to // be processed if (!result.contains(subiface)) { interfacesToProcess.add(subiface); } } } } return result; }
public static List<Class<?>> getSuperClassesAndInterfaces(Class<?> srcClass) { List<Class<?>> superClasses = new ArrayList<Class<?>>(); Class<?> realClass = getRealClass(srcClass); // Add all super classes first Class<?> superClass = getRealClass(realClass).getSuperclass(); while (!isBaseClass(superClass)) { superClasses.add(superClass); superClass = superClass.getSuperclass(); } // Now add all interfaces of the passed in class and all it's super classes // Linked hash set so duplicated are not added but insertion order is kept LinkedHashSet<Class<?>> interfaces = new LinkedHashSet<Class<?>>(); interfaces.addAll(getInterfaceHierarchy(realClass)); for (Class<?> clazz : superClasses) { interfaces.addAll(getInterfaceHierarchy(clazz)); } superClasses.addAll(interfaces); return superClasses; }
public static List<Class<?>> getSuperClassesAndInterfaces(Class<?> srcClass) { List<Class<?>> superClasses = new ArrayList<Class<?>>(); Class<?> realClass = getRealClass(srcClass); // Add all super classes first Class<?> superClass = getRealClass(realClass).getSuperclass(); while (!isBaseClass(superClass)) { superClasses.add(superClass); superClass = superClass.getSuperclass(); } // Now add all interfaces of the passed in class and all it's super // classes // Linked hash set so duplicated are not added but insertion order is // kept LinkedHashSet<Class<?>> interfaces = new LinkedHashSet<Class<?>>(); interfaces.addAll(getInterfaceHierarchy(realClass)); for (Class<?> clazz : superClasses) { interfaces.addAll(getInterfaceHierarchy(clazz)); } superClasses.addAll(interfaces); return superClasses; }
public static List<Class<?>> getSuperClassesAndInterfaces(Class<?> srcClass) { List<Class<?>> superClasses = new ArrayList<Class<?>>(); Class<?> realClass = getRealClass(srcClass); // Add all super classes first Class<?> superClass = getRealClass(realClass).getSuperclass(); while (!isBaseClass(superClass)) { superClasses.add(superClass); superClass = superClass.getSuperclass(); } // Now add all interfaces of the passed in class and all it's super // classes // Linked hash set so duplicated are not added but insertion order is // kept LinkedHashSet<Class<?>> interfaces = new LinkedHashSet<Class<?>>(); interfaces.addAll(getInterfaceHierarchy(realClass)); for (Class<?> clazz : superClasses) { interfaces.addAll(getInterfaceHierarchy(clazz)); } superClasses.addAll(interfaces); return superClasses; }
public Class<?> getHint(Class<?> clazz, List<Class<?>> clazzHints) { List<Class<?>> hintTypes = getHints(); int hintsSize = hintTypes.size(); if (hintsSize == 1) { return getHint(); } // validate sizes if (clazzHints.size() != hintsSize) { MappingUtils.throwMappingException( "When using multiple source and destination hints there must be exactly the same number of hints on the source and the destination."); } int count = 0; String myClazName = MappingUtils.getRealClass(clazz).getName(); int size = clazzHints.size(); for (int i = 0; i < size; i++) { Class<?> element = clazzHints.get(i); if (element.getName().equals(myClazName)) { return hintTypes.get(count); } count++; } return clazz; }
public Class<?> getHint(Class<?> clazz, List<Class<?>> clazzHints) { List<Class<?>> hints = getHints(); int hintsSize = hints.size(); if (hintsSize == 1) { return getHint(); } // validate sizes if (clazzHints.size() != hintsSize) { MappingUtils .throwMappingException("When using multiple source and destination hints there must be exactly the same number of hints on the source and the destination."); } int count = 0; String myClazName = MappingUtils.getRealClass(clazz).getName(); int size = clazzHints.size(); for (int i = 0; i < size; i++) { Class<?> element = clazzHints.get(i); if (element.getName().equals(myClazName)) { return hints.get(count); } count++; } return clazz; }
public Class<?> getHint(Class<?> clazz, List<Class<?>> clazzHints) { List<Class<?>> hintTypes = getHints(); int hintsSize = hintTypes.size(); if (hintsSize == 1) { return getHint(); } // validate sizes if (clazzHints.size() != hintsSize) { MappingUtils .throwMappingException("When using multiple source and destination hints there must be exactly the same number of hints on the source and the destination."); } int count = 0; String myClazName = MappingUtils.getRealClass(clazz).getName(); int size = clazzHints.size(); for (int i = 0; i < size; i++) { Class<?> element = clazzHints.get(i); if (element.getName().equals(myClazName)) { return hintTypes.get(count); } count++; } return clazz; }
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; }
if (MappingUtils.getRealClass(srcClass).equals(mappingSrcClass)) { return map;