@Override public AnnotatedClassType addClassType(XClass clazz) { AnnotatedClassType type; if ( clazz.isAnnotationPresent( Entity.class ) ) { type = AnnotatedClassType.ENTITY; } else if ( clazz.isAnnotationPresent( Embeddable.class ) ) { type = AnnotatedClassType.EMBEDDABLE; } else if ( clazz.isAnnotationPresent( javax.persistence.MappedSuperclass.class ) ) { type = AnnotatedClassType.EMBEDDABLE_SUPERCLASS; } else { type = AnnotatedClassType.NONE; } annotatedClassTypeMap.put( clazz.getName(), type ); return type; }
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 void insertMappedSuperclasses(List<XClass> original, List<XClass> copy) { for ( XClass clazz : original ) { XClass superClass = clazz.getSuperclass(); while ( superClass != null && !reflectionManager.equals( superClass, Object.class ) && !copy.contains( superClass ) ) { if ( superClass.isAnnotationPresent( Entity.class ) || superClass.isAnnotationPresent( javax.persistence.MappedSuperclass.class ) ) { copy.add( superClass ); } superClass = superClass.getSuperclass(); } } }
private void buildHierarchyColumnOverride(XClass element) { XClass current = element; Map<String, Column[]> columnOverride = new HashMap<String, Column[]>(); Map<String, JoinColumn[]> joinColumnOverride = new HashMap<String, JoinColumn[]>(); Map<String, JoinTable> joinTableOverride = new HashMap<String, JoinTable>(); Map<String, ForeignKey> foreignKeyOverride = new HashMap<String, ForeignKey>(); while ( current != null && !context.getBootstrapContext().getReflectionManager().toXClass( Object.class ).equals( current ) ) { if ( current.isAnnotationPresent( Entity.class ) || current.isAnnotationPresent( MappedSuperclass.class ) || current.isAnnotationPresent( Embeddable.class ) ) { //FIXME is embeddable override? Map<String, Column[]> currentOverride = buildColumnOverride( current, getPath() ); Map<String, JoinColumn[]> currentJoinOverride = buildJoinColumnOverride( current, getPath() ); Map<String, JoinTable> currentJoinTableOverride = buildJoinTableOverride( current, getPath() ); Map<String, ForeignKey> currentForeignKeyOverride = buildForeignKeyOverride( current, getPath() ); currentOverride.putAll( columnOverride ); //subclasses have precedence over superclasses currentJoinOverride.putAll( joinColumnOverride ); //subclasses have precedence over superclasses currentJoinTableOverride.putAll( joinTableOverride ); //subclasses have precedence over superclasses currentForeignKeyOverride.putAll( foreignKeyOverride ); //subclasses have precedence over superclasses columnOverride = currentOverride; joinColumnOverride = currentJoinOverride; joinTableOverride = currentJoinTableOverride; foreignKeyOverride = currentForeignKeyOverride; } current = current.getSuperclass(); } holderColumnOverride = columnOverride.size() > 0 ? columnOverride : null; holderJoinColumnOverride = joinColumnOverride.size() > 0 ? joinColumnOverride : null; holderJoinTableOverride = joinTableOverride.size() > 0 ? joinTableOverride : null; holderForeignKeyOverride = foreignKeyOverride.size() > 0 ? foreignKeyOverride : null; }
public XClass getClassWithIdClass(boolean evenIfSubclass) { if ( !evenIfSubclass && hasParents() ) { return null; } if ( clazz.isAnnotationPresent( IdClass.class ) ) { return clazz; } else { InheritanceState state = InheritanceState.getSuperclassInheritanceState( clazz, inheritanceStatePerClass ); if ( state != null ) { return state.getClassWithIdClass( true ); } else { return null; } } }
private AccessType determineDefaultAccessType() { for (XClass xclass = clazz; xclass != null; xclass = xclass.getSuperclass()) { if ( ( xclass.getSuperclass() == null || Object.class.getName().equals( xclass.getSuperclass().getName() ) ) && ( xclass.isAnnotationPresent( Entity.class ) || xclass.isAnnotationPresent( MappedSuperclass.class ) ) && xclass.isAnnotationPresent( Access.class ) ) { return AccessType.getAccessStrategy( xclass.getAnnotation( Access.class ).value() ); } } // Guess from identifier. // FIX: Shouldn't this be determined by the first attribute (i.e., field or property) with annotations, but without an // explicit Access annotation, according to JPA 2.0 spec 2.3.1: Default Access Type? for (XClass xclass = clazz; xclass != null && !Object.class.getName().equals(xclass.getName()); xclass = xclass.getSuperclass()) { if ( xclass.isAnnotationPresent( Entity.class ) || xclass.isAnnotationPresent( MappedSuperclass.class ) ) { for ( XProperty prop : xclass.getDeclaredProperties( AccessType.PROPERTY.getType() ) ) { final boolean isEmbeddedId = prop.isAnnotationPresent( EmbeddedId.class ); if ( prop.isAnnotationPresent( Id.class ) || isEmbeddedId ) { return AccessType.PROPERTY; } } for ( XProperty prop : xclass.getDeclaredProperties( AccessType.FIELD.getType() ) ) { final boolean isEmbeddedId = prop.isAnnotationPresent( EmbeddedId.class ); if ( prop.isAnnotationPresent( Id.class ) || isEmbeddedId ) { return AccessType.FIELD; } } } } throw new AnnotationException( "No identifier specified for entity: " + clazz ); }
final boolean canContainConvert = xClass.isAnnotationPresent( javax.persistence.Entity.class ) || xClass.isAnnotationPresent( javax.persistence.MappedSuperclass.class ) || xClass.isAnnotationPresent( javax.persistence.Embeddable.class ); if ( ! canContainConvert ) { return;
currentClazz = currentClazz.getSuperclass(); while ( currentClazz != null && !currentClazz.isAnnotationPresent( MappedSuperclass.class ) );
stopListeners = currentClazz.isAnnotationPresent( ExcludeSuperclassListeners.class ); stopDefaultListeners = currentClazz.isAnnotationPresent( ExcludeDefaultListeners.class ); && !( currentClazz.isAnnotationPresent( Entity.class ) || currentClazz.isAnnotationPresent( MappedSuperclass.class ) ) );
private static boolean isEntityClassType(XClass clazzToProcess, AnnotatedClassType classType) { if ( AnnotatedClassType.EMBEDDABLE_SUPERCLASS.equals( classType ) //will be processed by their subentities || AnnotatedClassType.NONE.equals( classType ) //to be ignored || AnnotatedClassType.EMBEDDABLE.equals( classType ) //allow embeddable element declaration ) { if ( AnnotatedClassType.NONE.equals( classType ) && clazzToProcess.isAnnotationPresent( org.hibernate.annotations.Entity.class ) ) { LOG.missingEntityAnnotation( clazzToProcess.getName() ); } return false; } if ( !classType.equals( AnnotatedClassType.ENTITY ) ) { throw new AnnotationException( "Annotated class should have a @javax.persistence.Entity, @javax.persistence.Embeddable or @javax.persistence.EmbeddedSuperclass annotation: " + clazzToProcess .getName() ); } return true; }
if ( clazzToProcess.isAnnotationPresent( PrimaryKeyJoinColumns.class ) || clazzToProcess.isAnnotationPresent( PrimaryKeyJoinColumn.class ) ) { LOG.invalidPrimaryKeyJoinColumnAnnotation( clazzToProcess.getName() );
final boolean isComponent = entityXClass.isAnnotationPresent( Embeddable.class ) || idXProperty.isAnnotationPresent( EmbeddedId.class );
final String discriminatorValue = clazzToProcess.isAnnotationPresent( DiscriminatorValue.class ) ? clazzToProcess.getAnnotation( DiscriminatorValue.class ).value() : null;
private void insertMappedSuperclasses(List<XClass> original, List<XClass> copy) { for ( XClass clazz : original ) { XClass superClass = clazz.getSuperclass(); while ( superClass != null && !reflectionManager.equals( superClass, Object.class ) && !copy.contains( superClass ) ) { if ( superClass.isAnnotationPresent( Entity.class ) || superClass.isAnnotationPresent( MappedSuperclass.class ) ) { copy.add( superClass ); } superClass = superClass.getSuperclass(); } } }
boolean mutable = true; if ( annotatedClass.isAnnotationPresent( Immutable.class ) ) { mutable = false; LOG.entityAnnotationOnNonRoot(annotatedClass.getName()); if (annotatedClass.isAnnotationPresent(Immutable.class)) { LOG.immutableAnnotationOnNonRoot(annotatedClass.getName()); if ( annotatedClass.isAnnotationPresent( Synchronize.class )) { Synchronize synchronizedWith = annotatedClass.getAnnotation(Synchronize.class); if ( annotatedClass.isAnnotationPresent(Subselect.class )) { Subselect subselect = annotatedClass.getAnnotation(Subselect.class); this.subselect = subselect.value(); if ( annotatedClass.isAnnotationPresent( Tuplizers.class ) ) { for (Tuplizer tuplizer : annotatedClass.getAnnotation( Tuplizers.class ).value()) { EntityMode mode = EntityMode.parse( tuplizer.entityMode() ); if ( annotatedClass.isAnnotationPresent( Tuplizer.class ) ) { Tuplizer tuplizer = annotatedClass.getAnnotation( Tuplizer.class ); EntityMode mode = EntityMode.parse( tuplizer.entityMode() );
while ( superClass != null && superClass.isAnnotationPresent( MappedSuperclass.class ) ) {
InheritanceState inheritanceState, EntityBinder entityBinder) { if ( clazzToProcess.isAnnotationPresent( DiscriminatorFormula.class ) ) { throw new MappingException( "@DiscriminatorFormula on joined inheritance not supported at this time" );
MetadataBuildingContext context) throws MappingException { if ( clazzToProcess.isAnnotationPresent( Entity.class ) && clazzToProcess.isAnnotationPresent( MappedSuperclass.class ) ) { throw new AnnotationException( "An entity cannot be annotated with both @Entity and @MappedSuperclass: " + clazzToProcess.getName() ); if ( clazzToProcess.isAnnotationPresent( Inheritance.class ) && clazzToProcess.isAnnotationPresent( MappedSuperclass.class ) ) { throw new AnnotationException( "An entity cannot be annotated with both @Inheritance and @MappedSuperclass: " + clazzToProcess.getName() ); List<UniqueConstraintHolder> uniqueConstraints = new ArrayList<>(); javax.persistence.Table tabAnn = null; if ( clazzToProcess.isAnnotationPresent( javax.persistence.Table.class ) ) { tabAnn = clazzToProcess.getAnnotation( javax.persistence.Table.class ); table = tabAnn.name(); if ( clazzToProcess.isAnnotationPresent( Table.class ) ) { LOG.invalidTableAnnotation( clazzToProcess.getName() );
buildingContext ); if ( collectionType.isAnnotationPresent( Embeddable.class ) || property.isAnnotationPresent( ElementCollection.class ) //JPA 2 ) {
|| property.isAnnotationPresent( Embedded.class ) || property.isAnnotationPresent( EmbeddedId.class ) || returnedClass.isAnnotationPresent( Embeddable.class );