public String componentModel() {
if (mapperConfigPrism != null && mapperPrism.values.componentModel() == null) {
return mapperConfigPrism.componentModel();
} else {
return mapperPrism.componentModel();
}
}
private Set<TypeElement> getMappers(
final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnvironment) {
Set<TypeElement> mapperTypes = new HashSet<TypeElement>();
for (TypeElement annotation : annotations) {
// Indicates that the annotation's type isn't on the class path of the compiled
// project. Let the compiler deal with that and print an appropriate error.
if (annotation.getKind() != ElementKind.ANNOTATION_TYPE) {
continue;
}
try {
Set<? extends Element> annotatedMappers =
roundEnvironment.getElementsAnnotatedWith(annotation);
for (Element mapperElement : annotatedMappers) {
TypeElement mapperTypeElement = asTypeElement(mapperElement);
// on some JDKs, RoundEnvironment.getElementsAnnotatedWith( ... ) returns types with
// annotations unknown to the compiler, even though they are not declared Mappers
if (mapperTypeElement != null && MapperPrism.getInstanceOn(mapperTypeElement) != null) {
mapperTypes.add(mapperTypeElement);
}
}
} catch (Throwable t) { // whenever that may happen, but just to stay on the save side
handleUncaughtError(annotation, t);
continue;
}
}
return mapperTypes;
}
public String implementationPackage() {
if (mapperConfigPrism != null && mapperPrism.values.implementationPackage() == null) {
return mapperConfigPrism.implementationPackage();
} else {
return mapperPrism.implementationPackage();
}
}
public CollectionMappingStrategyPrism getCollectionMappingStrategy() {
if (mapperConfigPrism != null && mapperPrism.values.collectionMappingStrategy() == null) {
return CollectionMappingStrategyPrism.valueOf(mapperConfigPrism.collectionMappingStrategy());
} else {
return CollectionMappingStrategyPrism.valueOf(mapperPrism.collectionMappingStrategy());
}
}
public String unmappedTargetPolicy() {
if (mapperConfigPrism != null && mapperPrism.values.unmappedTargetPolicy() == null) {
return mapperConfigPrism.unmappedTargetPolicy();
} else {
return mapperPrism.unmappedTargetPolicy();
}
}
public MappingInheritanceStrategyPrism getMappingInheritanceStrategy() {
if (mapperConfigPrism != null && mapperPrism.values.mappingInheritanceStrategy() == null) {
return MappingInheritanceStrategyPrism.valueOf(
mapperConfigPrism.mappingInheritanceStrategy());
} else {
return MappingInheritanceStrategyPrism.valueOf(mapperPrism.mappingInheritanceStrategy());
}
}
private boolean isMapToDefaultOnMapperAndMappingConfigLevel() {
final NullValueMappingStrategyPrism strategy;
if (mapperConfigPrism != null && mapperPrism.values.nullValueMappingStrategy() == null) {
strategy =
NullValueMappingStrategyPrism.valueOf(mapperConfigPrism.nullValueMappingStrategy());
} else {
strategy = NullValueMappingStrategyPrism.valueOf(mapperPrism.nullValueMappingStrategy());
}
return NullValueMappingStrategyPrism.RETURN_DEFAULT == strategy;
}
private MapperConfiguration(MapperPrism mapperPrism) {
this.mapperPrism = mapperPrism;
if (mapperPrism.values.config() != null) {
// TODO #737 Only a declared type makes sense here; Validate and raise graceful error;
// Also validate that @MapperConfig is present
this.config = (DeclaredType) mapperPrism.config();
this.mapperConfigPrism = MapperConfigPrism.getInstanceOn(config.asElement());
} else {
this.config = null;
this.mapperConfigPrism = null;
}
}
public Set<DeclaredType> uses() {
Set<DeclaredType> uses = new LinkedHashSet<DeclaredType>();
for (TypeMirror usedMapperType : mapperPrism.uses()) {
// TODO #737 Only declared type make sense here; Validate and raise graceful error;
uses.add((DeclaredType) usedMapperType);
}
if (mapperConfigPrism != null) {
for (TypeMirror usedMapperType : mapperConfigPrism.uses()) {
// TODO #737 Only declared type make sense here; Validate and raise graceful error;
uses.add((DeclaredType) usedMapperType);
}
}
return uses;
}
private List<MapperReference> initReferencedMappers(
TypeElement element, MapperConfiguration mapperConfig) {
List<MapperReference> result = new LinkedList<MapperReference>();
List<String> variableNames = new LinkedList<String>();
for (TypeMirror usedMapper : mapperConfig.uses()) {
DefaultMapperReference mapperReference =
DefaultMapperReference.getInstance(
typeFactory.getType(usedMapper),
MapperPrism.getInstanceOn(typeUtils.asElement(usedMapper)) != null,
typeFactory,
variableNames);
result.add(mapperReference);
variableNames.add(mapperReference.getVariableName());
}
return result;
}
public static MapperConfiguration getInstanceOn(Element e) {
return new MapperConfiguration(MapperPrism.getInstanceOn(e));
}
public List<TypeMirror> imports() {
return mapperPrism.imports();
}