import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
@Override
public <S, D> Set<D> mapAsSet(Iterable<S> source, Class<D> destinationClass) {
    Class<S> elclass = this.getElementClass(source);
    if(elclass==null){
        return new HashSet<D>(0);
    }
    addMappingIfNotRegistered(TypeFactory.valueOf(elclass),TypeFactory.valueOf(destinationClass));
    return this.mapper.mapAsSet(source,destinationClass);
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
@Override
public <S, D> List<D> mapAsList(Iterable<S> source, Class<D> destinationClass) {
    Class<S> elclass = this.getElementClass(source);
    if(elclass==null){
        return new ArrayList<D>(0);
    }
    addMappingIfNotRegistered(TypeFactory.valueOf(elclass),TypeFactory.valueOf(destinationClass));
    return this.mapper.mapAsList(source,destinationClass);
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
@Override
public <S, D> D[] mapAsArray(D[] destination, Iterable<S> source, Class<D> destinationClass) {
    Class<S> elclass = this.getElementClass(source);
    if(elclass==null){
        return (D[]) new Object[1];
    }
    addMappingIfNotRegistered(TypeFactory.valueOf(elclass),TypeFactory.valueOf(destinationClass));
    return this.mapper.mapAsArray(destination,source,destinationClass);
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
@Override
public <S, D> void mapAsCollection(Iterable<S> source, Collection<D> destination, Class<D> destinationClass) {
    Class<S> elclass = this.getElementClass(source);
    if(elclass==null){
        return;
    }
    addMappingIfNotRegistered(TypeFactory.valueOf(elclass),TypeFactory.valueOf(destinationClass));
    this.mapper.mapAsCollection(source,destination,destinationClass);
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
@Override
public <S, D> D newObject(S source, Type<? extends D> destinationType, MappingContext context) {
    if(source==null){
        return null;
    }
    addMappingIfNotRegistered(TypeFactory.valueOf(source.getClass()),destinationType);
    return this.mapper.newObject(source,destinationType,context);
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
/**
 * Constructs a new ClonerConverter configured to handle the provided list of types by
 * cloning.
 * @param cloneStrategy Strategy to be used
 * @param types one or more types that should be copied using the ClonerConverter
 */
public ClonerConverter(CloneStrategy cloneStrategy, java.lang.reflect.Type... types) {

    this.cloner = new BasicCloner(cloneStrategy);

    if (types.length == 0) {
        this.types = null;
    }
    for (java.lang.reflect.Type type : types) {
        this.types.add(TypeFactory.valueOf(type));
    }
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
/**
 * 指定复制的src和target的class.
 */
public <S, D> void copy(S src, D target, Class<S> srcClass,
        Class<D> targetClass) {
    mapper.map(src, target, TypeFactory.valueOf(srcClass),
            TypeFactory.valueOf(targetClass));
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
/**
 * 预先获取orika转换所需要的Type，避免每次转换.
 */
public static <E> Type<E> getType(final Class<E> rawType) {
	return TypeFactory.valueOf(rawType);
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
private void addMappingIfNotRegistered(Class<?> sourceClass, Class<?> destinationClass) {
    addMappingIfNotRegistered(TypeFactory.valueOf(sourceClass),TypeFactory.valueOf(destinationClass));
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
/**
 * Convert an object to a Map
 *
 * @param object object to convert
 * @return Map<String, Object> converted object
 */
protected Map<String, Object> convertObjectToMap(Object object) {
  Type objectType = TypeFactory.valueOf(object.getClass());
  Type mapType = new TypeBuilder<Map<String, Object>>() {
  }.build();

  MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
  mapperFactory.classMap(objectType, mapType).byDefault().register();
  BoundMapperFacade boundMapper = mapperFactory.getMapperFacade(objectType, mapType);
  Map<String, Object> convertedObject = (Map<String, Object>) boundMapper.map(object);

  return convertedObject;
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
/**
 * 简单的复制出新对象列表到ArrayList
 * 
 * 不建议使用mapper.mapAsList(Iterable<S>,Class<D>)接口, sourceClass需要反射，实在有点慢
 */
public static <S, D> List<D> mapList(Iterable<S> sourceList, Class<S> sourceClass, Class<D> destinationClass) {
	return mapper.mapAsList(sourceList, TypeFactory.valueOf(sourceClass), TypeFactory.valueOf(destinationClass));
}
 

import ma.glasnost.orika.metadata.TypeFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private <From, To> To doMapping(final Class<To> toClass, From from, String mappingName, MappingType mappingType, boolean beenMappedWithOrika, To to) {

    CustomMappingWrapper.Orika orikaOverrideSetting = CustomMappingWrapper.Orika.DEFAULT;

    if (from == null) return null;

    if (from instanceof CustomMappingWrapper) {
        CustomMappingWrapper cmo = (CustomMappingWrapper) from;
        from = (From)cmo.getObject();
        mappingType = cmo.getMappingType();
        mappingName = cmo.getMappingName();
        orikaOverrideSetting = cmo.getOrika();

        if (from == null) return null;

    }

    Class fromClass = from.getClass();

    boolean mappedWithOrika = false;

    if (orikaOverrideSetting == CustomMappingWrapper.Orika.FORCE_ON || (orikaOverrideSetting == CustomMappingWrapper.Orika.DEFAULT && (!beenMappedWithOrika && autoMapUsingOrika))) {

        //TODO move to cache
        MapperFacade orikaMapper;

        if (!mapperFactory.existsRegisteredMapper(TypeFactory.valueOf(from.getClass()), TypeFactory.valueOf(toClass), false)) {

            mapperFactory.classMap(fromClass, toClass)
                    .byDefault().register();
        }

        orikaMapper = mapperFactory.getMapperFacade();

        to = orikaMapper.map(from, toClass);

        beenMappedWithOrika = true;
        mappedWithOrika = true;

    }

    if (to == null) {
        try {
            to = toClass.newInstance();
        } catch (IllegalAccessException | InstantiationException e) {
            throw new RuntimeException("Error creating instace of " + toClass, e);
        }
    }

    doAudibleMapping(toClass, from, mappingName, mappingType, fromClass, to, beenMappedWithOrika, mappedWithOrika);

    handlePostProcessor(to, toClass, from, mappingName);

    return to;
}