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();
 }