private ClassDescriptor toClassDescriptor(ClassFile classFile, ArchiveEntry entry) {
	ClassDescriptor.Categorization categorization = ClassDescriptor.Categorization.OTHER;;

	final AnnotationsAttribute visibleAnnotations = (AnnotationsAttribute) classFile.getAttribute( AnnotationsAttribute.visibleTag );
	if ( visibleAnnotations != null ) {
		if ( visibleAnnotations.getAnnotation( Entity.class.getName() ) != null
				|| visibleAnnotations.getAnnotation( MappedSuperclass.class.getName() ) != null
				|| visibleAnnotations.getAnnotation( Embeddable.class.getName() ) != null ) {
			categorization = ClassDescriptor.Categorization.MODEL;
		}
		else if ( visibleAnnotations.getAnnotation( Converter.class.getName() ) != null ) {
			categorization = ClassDescriptor.Categorization.CONVERTER;
		}
	}

	return new ClassDescriptorImpl( classFile.getName(), categorization, entry.getStreamAccess() );
}
 

private AutoApplicableConverterDescriptor resolveAutoApplicableDescriptor(
		Class<? extends AttributeConverter> converterClass,
		Boolean forceAutoApply) {
	final boolean autoApply;

	if ( forceAutoApply != null ) {
		// if the caller explicitly specified whether to auto-apply, honor that
		autoApply = forceAutoApply;
	}
	else {
		// otherwise, look at the converter's @Converter annotation
		final Converter annotation = converterClass.getAnnotation( Converter.class );
		autoApply = annotation != null && annotation.autoApply();
	}

	return autoApply
			? new AutoApplicableConverterDescriptorStandardImpl( this )
			: AutoApplicableConverterDescriptorBypassedImpl.INSTANCE;
}
 

private void categorizeAnnotatedClass(Class annotatedClass, AttributeConverterManager attributeConverterManager) {
	final XClass xClass = reflectionManager.toXClass( annotatedClass );
	// categorize it, based on assumption it does not fall into multiple categories
	if ( xClass.isAnnotationPresent( Converter.class ) ) {
		//noinspection unchecked
		attributeConverterManager.addAttributeConverter( annotatedClass );
	}
	else if ( xClass.isAnnotationPresent( Entity.class )
			|| xClass.isAnnotationPresent( MappedSuperclass.class ) ) {
		xClasses.add( xClass );
	}
	else if ( xClass.isAnnotationPresent( Embeddable.class ) ) {
		xClasses.add( xClass );
	}
	else {
		log.debugf( "Encountered a non-categorized annotated class [%s]; ignoring", annotatedClass.getName() );
	}
}
 

private JavaFile createJavaFile(
    String packageName, String converterClassName, TypeMirror entityTypeMirror) {
  TypeName entityType = ClassName.get(entityTypeMirror);

  ParameterizedTypeName attributeConverter =
      ParameterizedTypeName.get(
          ClassName.get("google.registry.persistence.converter", "VKeyConverter"),
          entityType,
          ClassName.get(getSqlColumnType()));

  MethodSpec getAttributeClass =
      MethodSpec.methodBuilder("getAttributeClass")
          .addAnnotation(Override.class)
          .addModifiers(Modifier.PROTECTED)
          .returns(
              ParameterizedTypeName.get(
                  ClassName.get(Class.class), ClassName.get(entityTypeMirror)))
          .addStatement("return $T.class", entityType)
          .build();

  TypeSpec vKeyConverter =
      TypeSpec.classBuilder(converterClassName)
          .addAnnotation(
              AnnotationSpec.builder(ClassName.get(Converter.class))
                  .addMember("autoApply", "true")
                  .build())
          .addModifiers(Modifier.FINAL)
          .superclass(attributeConverter)
          .addMethod(getAttributeClass)
          .build();

  return JavaFile.builder(packageName, vKeyConverter).build();
}
 

private Set<String> findEntities(String[] allBasePackages, final URL[] classPath)
{
    final Set<String> result = new TreeSet<>();

    try (final ScanResult scanResult = new ClassGraph().whitelistPackages(allBasePackages).enableAnnotationInfo().overrideClasspath((Object[]) classPath).scan())
    {
        result.addAll(extract(scanResult, Entity.class));
        result.addAll(extract(scanResult, MappedSuperclass.class));
        result.addAll(extract(scanResult, Embeddable.class));
        result.addAll(extract(scanResult, Converter.class));
    }
    return result;
}
 

@Test
public void persistenceConverter() {
	testSingleComponent(SampleConverter.class, Converter.class);
}
 

@Test
public void persistenceConverter() {
	testSingleComponent(SampleConverter.class, Converter.class);
}
 

@Override
protected boolean match(Class<?> clazz) {
	return clazz.isAnnotationPresent(Converter.class);
}
 

/**
 * Build an AttributeConverterDefinition from an AttributeConverter instance.  The
 * converter is searched for a {@link Converter} annotation	 to determine whether it should
 * be treated as auto-apply.  If the annotation is present, {@link Converter#autoApply()} is
 * used to make that determination.  If the annotation is not present, {@code false} is assumed.
 *
 * @param attributeConverter The AttributeConverter instance
 *
 * @return The constructed definition
 */
public static AttributeConverterDefinition from(AttributeConverter attributeConverter) {
	boolean autoApply = false;
	Converter converterAnnotation = attributeConverter.getClass().getAnnotation( Converter.class );
	if ( converterAnnotation != null ) {
		autoApply = converterAnnotation.autoApply();
	}

	return new AttributeConverterDefinition( attributeConverter, autoApply );
}