#107 - hibernate-models-bytebuddy

# Conflicts:
#	hibernate-models/src/test/java/org/hibernate/models/testing/tests/MultiDimensionalArrayTypeTests.java

Author: sebersole

hibernate-models-bytebuddy/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id "published-java-module"
+}
+
+description = "Support for hibernate-models based on ByteBuddy (isolated dependency)"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api project( ":hibernate-models" )
+
+    implementation libs.byteBuddy
+
+    testImplementation project( ":hibernate-models-testing" )
+}

hibernate-models-bytebuddy/src/main/java/org/hibernate/models/bytebuddy/internal/AbstractAnnotationTarget.java

@@ -0,0 +1,45 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.bytebuddy.internal;
+
+import java.lang.annotation.Annotation;
+import java.util.Map;
+
+import org.hibernate.models.internal.AnnotationTargetSupport;
+
+import net.bytebuddy.description.annotation.AnnotationSource;
+
+/**
+ * @author Steve Ebersole
+ */
+public abstract class AbstractAnnotationTarget implements AnnotationTargetSupport {
+	private final SourceModelBuildingContextImpl modelContext;
+
+	private Map<Class<? extends Annotation>, ? extends Annotation> usageMap;
+
+	public AbstractAnnotationTarget(SourceModelBuildingContextImpl modelContext) {
+		this.modelContext = modelContext;
+	}
+
+	public SourceModelBuildingContextImpl getModelContext() {
+		return modelContext;
+	}
+
+	protected abstract AnnotationSource getAnnotationSource();
+
+	@Override
+	public Map<Class<? extends Annotation>, ? extends Annotation> getUsageMap() {
+		if ( usageMap == null ) {
+			usageMap = AnnotationUsageBuilder.collectUsages( getAnnotationSource(), modelContext );
+		}
+		return usageMap;
+	}
+
+	@Override
+	public void clearAnnotationUsages() {
+		getUsageMap().clear();
+	}
+
+}

hibernate-models-bytebuddy/src/main/java/org/hibernate/models/bytebuddy/internal/AnnotationDescriptorImpl.java

@@ -0,0 +1,35 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.bytebuddy.internal;
+
+import java.lang.annotation.Annotation;
+
+import org.hibernate.models.internal.StandardAnnotationDescriptor;
+import org.hibernate.models.spi.AnnotationDescriptor;
+import org.hibernate.models.spi.SourceModelBuildingContext;
+
+import net.bytebuddy.description.annotation.AnnotationDescription;
+
+/**
+ * @author Steve Ebersole
+ */
+public class AnnotationDescriptorImpl<A extends Annotation> extends StandardAnnotationDescriptor<A> {
+	public AnnotationDescriptorImpl(
+			Class<A> annotationType,
+			SourceModelBuildingContext buildingContext) {
+		super( annotationType, buildingContext );
+	}
+
+	public AnnotationDescriptorImpl(
+			Class<A> annotationType,
+			AnnotationDescriptor<?> repeatableContainer,
+			SourceModelBuildingContext buildingContext) {
+		super( annotationType, repeatableContainer, buildingContext );
+	}
+
+	public A createUsage(AnnotationDescription annotationDescription, SourceModelBuildingContextImpl context) {
+		return AnnotationUsageBuilder.makeUsage( annotationDescription, this, context );
+	}
+}

hibernate-models-bytebuddy/src/main/java/org/hibernate/models/bytebuddy/internal/AnnotationDescriptorRegistryImpl.java

@@ -0,0 +1,32 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.bytebuddy.internal;
+
+import java.lang.annotation.Annotation;
+import java.util.Map;
+
+import org.hibernate.models.internal.AnnotationDescriptorRegistryStandard;
+import org.hibernate.models.spi.AnnotationDescriptor;
+import org.hibernate.models.spi.SourceModelBuildingContext;
+
+/**
+ * @author Steve Ebersole
+ */
+public class AnnotationDescriptorRegistryImpl extends AnnotationDescriptorRegistryStandard {
+	public AnnotationDescriptorRegistryImpl(SourceModelBuildingContext modelBuildingContext) {
+		super( modelBuildingContext );
+	}
+
+	@Override
+	protected <A extends Annotation> AnnotationDescriptor<A> buildAnnotationDescriptor(
+			Class<A> javaType,
+			AnnotationDescriptor<? extends Annotation> containerDescriptor) {
+		return new AnnotationDescriptorImpl<>( javaType, containerDescriptor, getModelBuildingContext() );
+	}
+
+	public Map<Class<? extends Annotation>, AnnotationDescriptor<? extends Annotation>> getDescriptorMap() {
+		return descriptorMap;
+	}
+}

hibernate-models-bytebuddy/src/main/java/org/hibernate/models/bytebuddy/internal/AnnotationUsageBuilder.java

@@ -0,0 +1,116 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.bytebuddy.internal;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
+
+import org.hibernate.models.bytebuddy.spi.ValueExtractor;
+import org.hibernate.models.internal.util.CollectionHelper;
+import org.hibernate.models.spi.AnnotationDescriptor;
+import org.hibernate.models.spi.AnnotationDescriptorRegistry;
+import org.hibernate.models.spi.AttributeDescriptor;
+
+import net.bytebuddy.description.annotation.AnnotationDescription;
+import net.bytebuddy.description.annotation.AnnotationList;
+import net.bytebuddy.description.annotation.AnnotationSource;
+
+/**
+ * Helper for building annotation usages/instances based on
+ * Jandex {@linkplain AnnotationDescription} references
+ *
+ * @author Steve Ebersole
+ */
+public class AnnotationUsageBuilder {
+	public static <A extends Annotation> A makeUsage(
+			AnnotationDescription annotationDescription,
+			AnnotationDescriptor<A> annotationDescriptor,
+			SourceModelBuildingContextImpl modelContext) {
+		final Map<String, Object> attributeValues = extractAttributeValues(
+				annotationDescription,
+				annotationDescriptor,
+				modelContext
+		);
+		return annotationDescriptor.createUsage( attributeValues, modelContext );
+	}
+
+	private static <A extends Annotation> Map<String, Object> extractAttributeValues(
+			AnnotationDescription annotationDescription,
+			AnnotationDescriptor<A> annotationDescriptor,
+			SourceModelBuildingContextImpl modelContext) {
+
+		if ( CollectionHelper.isEmpty( annotationDescriptor.getAttributes() ) ) {
+			return Collections.emptyMap();
+		}
+
+		final ConcurrentHashMap<String, Object> valueMap = new ConcurrentHashMap<>();
+		for ( int i = 0; i < annotationDescriptor.getAttributes().size(); i++ ) {
+			final AttributeDescriptor<?> attributeDescriptor = annotationDescriptor.getAttributes().get( i );
+			final ValueExtractor<?> extractor = modelContext
+					.as( SourceModelBuildingContextImpl.class )
+					.getValueExtractor( attributeDescriptor.getTypeDescriptor() );
+			final Object attributeValue = extractor.extractValue(
+					annotationDescription,
+					attributeDescriptor.getName(),
+					modelContext
+			);
+			valueMap.put( attributeDescriptor.getName(), attributeValue );
+		}
+		return valueMap;
+	}
+
+	public static Map<Class<? extends Annotation>, ? extends Annotation> collectUsages(
+			AnnotationSource annotationSource,
+			SourceModelBuildingContextImpl modelContext) {
+		if ( annotationSource == null ) {
+			return Collections.emptyMap();
+		}
+		final Map<Class<? extends Annotation>, Annotation> result = new HashMap<>();
+		processAnnotations(
+				annotationSource.getDeclaredAnnotations(),
+				result::put,
+				modelContext
+		);
+		return result;
+	}
+
+	/**
+	 * Process annotations creating usage instances passed back to the consumer
+	 */
+	public static void processAnnotations(
+			AnnotationList annotations,
+			BiConsumer<Class<? extends Annotation>, Annotation> consumer,
+			SourceModelBuildingContextImpl buildingContext) {
+		final AnnotationDescriptorRegistry annotationDescriptorRegistry = buildingContext.getAnnotationDescriptorRegistry();
+
+		for ( AnnotationDescription annotation : annotations ) {
+			if ( annotation.getAnnotationType().represents( Documented.class )
+					|| annotation.getAnnotationType().represents( Repeatable.class )
+					|| annotation.getAnnotationType().represents( Retention.class )
+					|| annotation.getAnnotationType().represents( Target.class ) ) {
+				continue;
+			}
+
+			final Class<? extends Annotation> annotationType = buildingContext
+					.getClassLoading()
+					.classForName( annotation.getAnnotationType().getTypeName() );
+			final AnnotationDescriptor<?> annotationDescriptor = annotationDescriptorRegistry.getDescriptor( annotationType );
+			final Annotation usage = makeUsage(
+					annotation,
+					annotationDescriptor,
+					buildingContext
+			);
+			consumer.accept( annotationType, usage );
+		}
+	}
+}

hibernate-models-bytebuddy/src/main/java/org/hibernate/models/bytebuddy/internal/ClassDetailsBuilderImpl.java

@@ -0,0 +1,26 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.bytebuddy.internal;
+
+import org.hibernate.models.spi.ClassDetails;
+import org.hibernate.models.spi.ClassDetailsBuilder;
+import org.hibernate.models.spi.SourceModelBuildingContext;
+
+/**
+ * @author Steve Ebersole
+ */
+public class ClassDetailsBuilderImpl implements ClassDetailsBuilder {
+	private final SourceModelBuildingContextImpl modelContext;
+
+	public ClassDetailsBuilderImpl(SourceModelBuildingContextImpl modelContext) {
+		this.modelContext = modelContext;
+	}
+
+	@Override
+	public ClassDetails buildClassDetails(String name, SourceModelBuildingContext buildingContext) {
+		assert buildingContext == modelContext;
+		return ModelBuilders.buildDetails( name, modelContext );
+	}
+}