public static boolean shouldIgnoreField(String fieldName, Class<?> srcType, Class<?> destType) {
   if (CLASS.equals(fieldName)) {
     return true;
   }
   if ((CALLBACK.equals(fieldName) || CALLBACKS.equals(fieldName))
       && (MappingUtils.isProxy(srcType) || MappingUtils.isProxy(destType))) {
     return true;
   }
   return false;
 }
  public static void addGenericMapping(
      ClassMap classMap,
      Configuration configuration,
      String srcName,
      String destName,
      CustomMapping mapping,
      Boolean isField) {
    FieldMap fieldMap = new GenericFieldMap(classMap);

    DozerField sourceField = new DozerField(srcName, null);
    DozerField destField = new DozerField(destName, null);

    if (isField.booleanValue()) {
      sourceField.setAccessible(true);
      destField.setAccessible(true);
    }

    // Add mapping
    fieldMap.setSrcField(sourceField);
    fieldMap.setDestField(destField);

    // Add relationship-type
    fieldMap.setRelationshipType(RelationshipType.valueOf(mapping.relationshipType().trim()));

    // Add remove orphan
    fieldMap.setRemoveOrphans(mapping.removeOrphans());

    // add CopyByReferences per defect #1728159
    MappingUtils.applyGlobalCopyByReference(configuration, fieldMap, classMap);
    classMap.addFieldMapping(fieldMap);
  }
 public Object create(BeanCreationDirective directive) {
   Class<?> classToCreate = directive.getActualClass();
   String factoryBeanId = directive.getFactoryId();
   String beanId =
       !MappingUtils.isBlankOrNull(factoryBeanId) ? factoryBeanId : classToCreate.getName();
   return xmlBeanFactory.createBean(directive.getSrcObject(), directive.getSrcClass(), beanId);
 }
 private Method findMethod(Class<?> actualClass, String createMethod) {
   Method method = null;
   try {
     method = ReflectionUtils.getMethod(actualClass, createMethod, null);
   } catch (NoSuchMethodException e) {
     MappingUtils.throwMappingException(e);
   }
   return method;
 }
    public Object create(BeanCreationDirective directive) {
      Class<?> classToCreate = directive.getActualClass();
      String factoryName = directive.getFactoryName();
      String factoryBeanId = directive.getFactoryId();

      // By default, use dest object class name for factory bean id
      String beanId =
          !MappingUtils.isBlankOrNull(factoryBeanId) ? factoryBeanId : classToCreate.getName();

      BeanFactory factory = factoryCache.get(factoryName);
      if (factory == null) {
        Class<?> factoryClass = MappingUtils.loadClass(factoryName);
        if (!BeanFactory.class.isAssignableFrom(factoryClass)) {
          MappingUtils.throwMappingException(
              "Custom bean factory must implement "
                  + BeanFactory.class.getName()
                  + " interface : "
                  + factoryClass);
        }
        factory = (BeanFactory) ReflectionUtils.newInstance(factoryClass);
        // put the created factory in our factory map
        factoryCache.put(factoryName, factory);
      }

      Object result = factory.createBean(directive.getSrcObject(), directive.getSrcClass(), beanId);

      log.debug(
          "Bean instance created with custom factory -->\n  Bean Type: {}\n  Factory Name: {}",
          result.getClass().getName(),
          factoryName);

      if (!classToCreate.isAssignableFrom(result.getClass())) {
        MappingUtils.throwMappingException(
            "Custom bean factory ("
                + factory.getClass()
                + ") did not return correct type of destination data object. Expected : "
                + classToCreate
                + ", Actual : "
                + result.getClass());
      }
      return result;
    }
    public Object create(BeanCreationDirective directive) {
      Class<?> classToCreate = directive.getActualClass();

      try {
        return newInstance(classToCreate);
      } catch (Exception e) {
        if (directive.getAlternateClass() != null) {
          return newInstance(directive.getAlternateClass());
        } else {
          MappingUtils.throwMappingException(e);
        }
      }
      return null;
    }
  private Configuration findConfiguration(List<MappingFileData> mappingFileDataList) {
    Configuration globalConfiguration = null;
    for (MappingFileData mappingFileData : mappingFileDataList) {
      if (mappingFileData.getConfiguration() != null) {
        // Only allow 1 global configuration
        if (globalConfiguration != null) {
          MappingUtils.throwMappingException(
              "More than one global configuration found.  "
                  + "Only one global configuration block (<configuration></configuration>) can be specified across all mapping files.  "
                  + "You need to consolidate all global configuration blocks into a single one.");
        }
        globalConfiguration = mappingFileData.getConfiguration();
      }
    }

    // If global configuration was not specified, use defaults
    if (globalConfiguration == null) {
      globalConfiguration = new Configuration();
    }

    return globalConfiguration;
  }
    private static <T> T newInstance(Class<T> clazz) {
      // Create using public or private no-arg constructor
      Constructor<T> constructor = null;
      try {
        constructor = clazz.getDeclaredConstructor(null);
      } catch (SecurityException e) {
        MappingUtils.throwMappingException(e);
      } catch (NoSuchMethodException e) {
        MappingUtils.throwMappingException(e);
      }

      if (constructor == null) {
        MappingUtils.throwMappingException(
            "Could not create a new instance of the dest object: "
                + clazz
                + ".  Could not find a no-arg constructor for this class.");
      }

      // If private, make it accessible
      if (!constructor.isAccessible()) {
        constructor.setAccessible(true);
      }

      T result = null;
      try {
        result = constructor.newInstance(null);
      } catch (IllegalArgumentException e) {
        MappingUtils.throwMappingException(e);
      } catch (InstantiationException e) {
        MappingUtils.throwMappingException(e);
      } catch (IllegalAccessException e) {
        MappingUtils.throwMappingException(e);
      } catch (InvocationTargetException e) {
        MappingUtils.throwMappingException(e);
      }
      return result;
    }
 public boolean isApplicable(BeanCreationDirective directive) {
   String factoryName = directive.getFactoryName();
   return !MappingUtils.isBlankOrNull(factoryName);
 }
 public boolean isApplicable(BeanCreationDirective directive) {
   String createMethod = directive.getCreateMethod();
   return !MappingUtils.isBlankOrNull(createMethod);
 }