#88 - Ability to remove annotations from a target

#89 - Method to iterate all persistable members

Author: sebersole

src/main/java/org/hibernate/models/internal/AnnotationTargetSupport.java

@@ -42,6 +42,11 @@ default <X extends Annotation> void addAnnotationUsage(X annotationUsage) {
 		( (Map) getUsageMap() ).put( annotationUsage.annotationType(), annotationUsage );
 	}
 
+	@Override
+	default <X extends Annotation> void removeAnnotationUsage(AnnotationDescriptor<X> annotationType) {
+		getUsageMap().remove( annotationType.getAnnotationType() );
+	}
+
 	@Override
 	default Collection<? extends Annotation> getDirectAnnotationUsages() {
 		return getUsageMap().values();

src/main/java/org/hibernate/models/internal/ClassDetailsSupport.java

@@ -48,6 +48,18 @@ default void forEachMethod(IndexedConsumer<MethodDetails> consumer) {
 		}
 	}
 
+	@Override
+	default void forEachRecordComponent(IndexedConsumer<RecordComponentDetails> consumer) {
+		final List<RecordComponentDetails> recordComponents = getRecordComponents();
+		if ( recordComponents == null ) {
+			return;
+		}
+
+		for ( int i = 0; i < recordComponents.size(); i++ ) {
+			consumer.accept( i, recordComponents.get( i ) );
+		}
+	}
+
 	@Override
 	default <A extends Annotation> A getAnnotationUsage(
 			AnnotationDescriptor<A> descriptor,

src/main/java/org/hibernate/models/internal/SimpleClassDetails.java

@@ -144,6 +144,9 @@ public List<RecordComponentDetails> getRecordComponents() {
 		return Collections.emptyList();
 	}
 
+	@Override
+	public void forEachRecordComponent(IndexedConsumer<RecordComponentDetails> consumer) {
+	}
 
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// nor do we care about its annotations

src/main/java/org/hibernate/models/spi/ClassDetails.java

@@ -8,6 +8,7 @@
 
 import java.lang.annotation.Annotation;
 import java.util.List;
+import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 import org.hibernate.models.IllegalCastException;
@@ -251,6 +252,36 @@ default RecordComponentDetails findRecordComponentByName(String name) {
 		return findRecordComponent( component -> name.equals( component.getName() ) );
 	}
 
+	/**
+	 * Visit each method
+	 */
+	void forEachRecordComponent(IndexedConsumer<RecordComponentDetails> consumer);
+
+	default void forEachMember(Consumer<MemberDetails> consumer) {
+		forEachField( (i,field) -> consumer.accept( field ) );
+		forEachMethod( (i,method) -> consumer.accept( method ) );
+		forEachRecordComponent( (i,recordComponent) -> consumer.accept( recordComponent ) );
+	}
+
+	default void forEachPersistableMember(Consumer<MemberDetails> consumer) {
+		forEachField( (i,field) -> {
+			if ( field.isPersistable() ) {
+				consumer.accept( field );
+			}
+		} );
+		forEachMethod( (i,method) -> {
+			if ( method.isPersistable() ) {
+				consumer.accept( method );
+			}
+		} );
+		forEachRecordComponent( (i,recordComponent) -> {
+			// can they ever not be?
+			if ( recordComponent.isPersistable() ) {
+				consumer.accept( recordComponent );
+			}
+		} );
+	}
+
 	/**
 	 * Know what you are doing before calling this method
 	 */

src/main/java/org/hibernate/models/spi/MutableAnnotationTarget.java

@@ -25,6 +25,11 @@ public interface MutableAnnotationTarget extends AnnotationTarget {
 	 */
 	<X extends Annotation> void addAnnotationUsage(X annotationUsage);
 
+	/**
+	 * Remove an annotation, by type, from this target if there is such a usage.
+	 */
+	<X extends Annotation> void removeAnnotationUsage(AnnotationDescriptor<X> annotationType);
+
 	/**
 	 * Applies a usage of the given {@code annotationType} to this target.  Will return
 	 * an existing usage, if one, or create a new usage.
@@ -45,9 +50,8 @@ default <A extends Annotation> A applyAnnotationUsage(
 	/**
 	 * Creates and replaces (if any) an existing usage of the given annotation.
 	 * <p/>
-	 * For repeatable annotations, use
-	 * Applies a usage of the given {@code annotationType} to this target.  Will return
-	 * an existing usage, if one, or create a new usage.
+	 * For repeatable annotations, use {@linkplain #replaceAnnotationUsage(AnnotationDescriptor, AnnotationDescriptor, SourceModelBuildingContext)}
+	 * instead.
 	 *
 	 * @apiNote Generally replacement is used with XML processing and, again generally,
 	 * only for repeatable annotations using

src/test/java/org/hibernate/models/orm/JpaAnnotations.java

@@ -29,6 +29,7 @@
 import jakarta.persistence.SequenceGenerator;
 import jakarta.persistence.SequenceGenerators;
 import jakarta.persistence.Table;
+import jakarta.persistence.Transient;
 import jakarta.persistence.UniqueConstraint;
 
 /**
@@ -65,6 +66,7 @@ public interface JpaAnnotations {
 	AnnotationDescriptor<Index> INDEX = new OrmAnnotationDescriptor<>( Index.class, IndexAnnotation.class );
 
 	AnnotationDescriptor<Cacheable> CACHEABLE = new OrmAnnotationDescriptor<>( Cacheable.class, CacheableAnnotation.class );
+	AnnotationDescriptor<Transient> TRANSIENT = new OrmAnnotationDescriptor<>( Transient.class, TransientAnnotation.class );
 
 //	AnnotationDescriptor<Access> ACCESS = createOrmDescriptor( Access.class );
 //	AnnotationDescriptor<AssociationOverrides> ASSOCIATION_OVERRIDES = createOrmDescriptor( AssociationOverrides.class );

src/test/java/org/hibernate/models/orm/TransientAnnotation.java

@@ -0,0 +1,34 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+
+package org.hibernate.models.orm;
+
+import java.lang.annotation.Annotation;
+
+import org.hibernate.models.spi.SourceModelBuildingContext;
+
+import org.jboss.jandex.AnnotationInstance;
+
+import jakarta.persistence.Transient;
+
+/**
+ * @author Steve Ebersole
+ */
+@SuppressWarnings({ "ClassExplicitlyAnnotation", "unused" })
+public class TransientAnnotation implements Transient {
+	public TransientAnnotation(SourceModelBuildingContext modelContext) {
+	}
+	public TransientAnnotation(Transient source, SourceModelBuildingContext modelContext) {
+	}
+	public TransientAnnotation(AnnotationInstance source, SourceModelBuildingContext modelContext) {
+	}
+
+	@Override
+	public Class<? extends Annotation> annotationType() {
+		return Transient.class;
+	}
+}

src/test/java/org/hibernate/models/xml/MetadataCompleteTests.java

@@ -0,0 +1,66 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+
+package org.hibernate.models.xml;
+
+import org.hibernate.models.SourceModelTestHelper;
+import org.hibernate.models.internal.SourceModelBuildingContextImpl;
+import org.hibernate.models.orm.JpaAnnotations;
+import org.hibernate.models.spi.ClassDetails;
+import org.hibernate.models.spi.ClassDetailsRegistry;
+import org.hibernate.models.spi.FieldDetails;
+import org.hibernate.models.spi.MutableMemberDetails;
+
+import org.junit.jupiter.api.Test;
+
+import org.jboss.jandex.Index;
+
+import jakarta.persistence.Transient;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for expected patterns for handling of "metadata complete" XML mappings.
+ *
+ * @author Steve Ebersole
+ */
+public class MetadataCompleteTests {
+	@Test
+	void testIt() {
+		final SourceModelBuildingContextImpl buildingContext = SourceModelTestHelper.createBuildingContext(
+				(Index) null,
+				SimpleEntity.class
+		);
+
+		final ClassDetailsRegistry classDetailsRegistry = buildingContext.getClassDetailsRegistry();
+		final ClassDetails classDetails = classDetailsRegistry.getClassDetails( SimpleEntity.class.getName() );
+
+		// A metadata-complete XML mapping means that all "attributes" not explicitly listed in
+		// the XML should be ignored.  To support this we will first apply `@Transient` to all
+		// persistable members of the class.  Then, as we process the XML and "see" an attribute
+		// we will remove that annotation.
+
+		// mark them all transient...
+		classDetails.forEachPersistableMember( (member) -> ( (MutableMemberDetails) member ).applyAnnotationUsage( JpaAnnotations.TRANSIENT, buildingContext ) );
+
+		checkFieldIsTransient( classDetails.findFieldByName( "id" ), true );
+		checkFieldIsTransient( classDetails.findFieldByName( "name" ), true );
+		checkFieldIsTransient( classDetails.findFieldByName( "somethingElse" ), true );
+
+		// the XML lists just `id` and `name`...
+		( (MutableMemberDetails) classDetails.findFieldByName( "id" ) ).removeAnnotationUsage( JpaAnnotations.TRANSIENT );
+		( (MutableMemberDetails) classDetails.findFieldByName( "name" ) ).removeAnnotationUsage( JpaAnnotations.TRANSIENT );
+
+		checkFieldIsTransient( classDetails.findFieldByName( "id" ), false );
+		checkFieldIsTransient( classDetails.findFieldByName( "name" ), false );
+		checkFieldIsTransient( classDetails.findFieldByName( "somethingElse" ), true );
+	}
+
+	private void checkFieldIsTransient(FieldDetails fieldDetails, boolean expectation) {
+		assertThat( fieldDetails.hasDirectAnnotationUsage( Transient.class ) ).isEqualTo( expectation );
+	}
+}

src/test/java/org/hibernate/models/xml/SimpleEntity.java

@@ -0,0 +1,46 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+
+package org.hibernate.models.xml;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Basic;
+
+/**
+ * @author Steve Ebersole
+ */
+@SuppressWarnings("unused")
+@Entity
+public class SimpleEntity {
+	@Id
+	private Integer id;
+	@Basic
+	private String name;
+	private String somethingElse;
+
+	protected SimpleEntity() {
+		// for Hibernate use
+	}
+
+	public SimpleEntity(Integer id, String name) {
+		this.id = id;
+		this.name = name;
+	}
+
+	public Integer getId() {
+		return id;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+}