import ma.glasnost.orika.metadata.Type; //导入依赖的package包/类
@Override
public <S, D> boolean shouldMap(Type<S> type, String s, S s1, Type<D> type1, String s2, D d,
    MappingContext mappingContext) {
  if (type != null && s1 != null) {
    if (type.isCollection()) {
      if (s1 instanceof AbstractPersistentCollection) {
        return false;
      }

      if (((PersistentSet) s1).wasInitialized()) {
        return false;
      }
    }
  }

  return true;
}
 

import ma.glasnost.orika.metadata.Type; //导入依赖的package包/类
public MappingBuilder(MapperFactory mapperFactory, Type<?> sourceType, Type<?> destinationType, ApplicationContext applicationContext) {
    this.sourceType = sourceType;
    this.destinationType = destinationType;
    this.mapperFactory = mapperFactory;
    this.sourceClass = this.sourceType.getRawType();
    this.destinationClass = this.destinationType.getRawType();
    this.buildMapping();
    this.buildConverts();
    this.applicationContext = applicationContext;
}
 

import ma.glasnost.orika.metadata.Type; //导入依赖的package包/类
private void addMappingIfNotRegistered(Type<?> sourceType, Type<?> destinationType){

        if(!this.mapperFactory.existsRegisteredMapper(sourceType,destinationType,true)){
            synchronized (mapperBuildLock){
                if(!this.mapperFactory.existsRegisteredMapper(sourceType,destinationType,true)) {
                    new MappingBuilder(this.mapperFactory, sourceType, destinationType,applicationContext).build();
                }
            }
        }

    }
 

import ma.glasnost.orika.metadata.Type; //导入依赖的package包/类
@Override
public <S, D> void map(S sourceObject, D destinationObject, Type<S> sourceType, Type<D> destinationType) {
    if(sourceObject==null){
        return;
    }
    addMappingIfNotRegistered(sourceType,destinationType);
    this.mapper.map(sourceObject,destinationObject,sourceType,destinationType);
}
 

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

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

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

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

import ma.glasnost.orika.metadata.Type; //导入依赖的package包/类
@Override
public <S, D> D convert(S source, Type<S> sourceType, Type<D> destinationType, String converterId) {
    if(source==null){
        return null;
    }
    addMappingIfNotRegistered(sourceType,destinationType);
    return this.mapper.convert(source,sourceType,destinationType,converterId);
}
 

import ma.glasnost.orika.metadata.Type; //导入依赖的package包/类
@Override
public <Sk, Sv, Dk, Dv> Map<Dk, Dv> mapAsMap(Map<Sk, Sv> source, Type<? extends Map<Sk, Sv>> sourceType, Type<? extends Map<Dk, Dv>> destinationType) {
    if(source==null){
        return null;
    }
    addMappingIfNotRegistered(sourceType,destinationType);
    return this.mapper.mapAsMap(source,sourceType,destinationType);
}
 

import ma.glasnost.orika.metadata.Type; //导入依赖的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.Type; //导入依赖的package包/类
@Override
public BasicInfo convert(BasicInfo source, Type<? extends BasicInfo> destinationType, MappingContext mappingContext) {
    if (source == null) {
        return null;
    }

    return new BasicInfo(source.getKeyword(), source.getName(), source.getArguments());
}
 

import ma.glasnost.orika.metadata.Type; //导入依赖的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));
    }
}