public static InheritanceState getSuperclassInheritanceState(XClass clazz, Map<XClass, InheritanceState> states) { XClass superclass = clazz; do { superclass = superclass.getSuperclass(); InheritanceState currentState = states.get( superclass ); if ( currentState != null ) { return currentState; } } while ( superclass != null && !Object.class.getName().equals( superclass.getName() ) ); return null; }
private void orderHierarchy(List<XClass> copy, List<XClass> newList, List<XClass> original, XClass clazz) { if ( clazz == null || reflectionManager.equals( clazz, Object.class ) ) { return; } //process superclass first orderHierarchy( copy, newList, original, clazz.getSuperclass() ); if ( original.contains( clazz ) ) { if ( !newList.contains( clazz ) ) { newList.add( clazz ); } copy.remove( clazz ); } }
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(); } } }
public static InheritanceState getInheritanceStateOfSuperEntity( XClass clazz, Map<XClass, InheritanceState> states ) { XClass superclass = clazz; do { superclass = superclass.getSuperclass(); InheritanceState currentState = states.get( superclass ); if ( currentState != null && !currentState.isEmbeddableSuperclass() ) { return currentState; } } while ( superclass != null && !Object.class.getName().equals( superclass.getName() ) ); return null; }
private static void bindFilters( XClass annotatedClass, EntityBinder entityBinder, MetadataBuildingContext context) { bindFilters( annotatedClass, entityBinder ); XClass classToProcess = annotatedClass.getSuperclass(); while ( classToProcess != null ) { AnnotatedClassType classType = context.getMetadataCollector().getClassType( classToProcess ); if ( AnnotatedClassType.EMBEDDABLE_SUPERCLASS.equals( classType ) ) { bindFilters( classToProcess, entityBinder ); } else { break; } classToProcess = classToProcess.getSuperclass(); } }
private void getMappedSuperclassesTillNextEntityOrdered() { //ordered to allow proper messages on properties subclassing XClass currentClassInHierarchy = clazz; InheritanceState superclassState; do { classesToProcessForMappedSuperclass.add( 0, currentClassInHierarchy ); XClass superClass = currentClassInHierarchy; do { superClass = superClass.getSuperclass(); superclassState = inheritanceStatePerClass.get( superClass ); } while ( superClass != null && !buildingContext.getBootstrapContext().getReflectionManager().equals( superClass, Object.class ) && superclassState == null ); currentClassInHierarchy = superClass; } while ( superclassState != null && superclassState.isEmbeddableSuperclass() ); }
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; }
private void searchForRevisionInfoCfg( XClass clazz, ReflectionManager reflectionManager, MutableBoolean revisionNumberFound, MutableBoolean revisionTimestampFound, MutableBoolean modifiedEntityNamesFound) { final XClass superclazz = clazz.getSuperclass(); if ( !"java.lang.Object".equals( superclazz.getName() ) ) { searchForRevisionInfoCfg( superclazz, reflectionManager, revisionNumberFound, revisionTimestampFound, modifiedEntityNamesFound ); } searchForRevisionInfoCfgInProperties( clazz, reflectionManager, revisionNumberFound, revisionTimestampFound, modifiedEntityNamesFound, "field" ); searchForRevisionInfoCfgInProperties( clazz, reflectionManager, revisionNumberFound, revisionTimestampFound, modifiedEntityNamesFound, "property" ); }
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 ); }
currentClazz = currentClazz.getSuperclass();
final XClass superclass = clazz.getSuperclass(); if ( !clazz.isInterface() && !Object.class.getName().equals( superclass.getName() ) ) { readAuditOverrides( superclass );
/** * Recursively adds all audited properties of entity class and its superclasses. * * @param clazz Currently processed class. */ private void addPropertiesFromClass(XClass clazz) { final Audited allClassAudited = computeAuditConfiguration( clazz ); //look in the class addFromProperties( clazz.getDeclaredProperties( "field" ), it -> "field", fieldAccessedPersistentProperties, allClassAudited ); addFromProperties( clazz.getDeclaredProperties( "property" ), propertyAccessedPersistentProperties::get, propertyAccessedPersistentProperties.keySet(), allClassAudited ); if ( allClassAudited != null || !auditedPropertiesHolder.isEmpty() ) { final XClass superclazz = clazz.getSuperclass(); if ( !clazz.isInterface() && !"java.lang.Object".equals( superclazz.getName() ) ) { addPropertiesFromClass( superclazz ); } } }
currentClazz = currentClazz.getSuperclass();
collectAttributeConversionInfo( infoMap, xClass.getSuperclass() );
public static InheritanceState getSuperclassInheritanceState( XClass clazz, Map<XClass, InheritanceState> states) { XClass superclass = clazz; do { superclass = superclass.getSuperclass(); InheritanceState currentState = states.get( superclass ); if ( currentState != null ) { return currentState; } } while ( superclass != null && !Object.class.getName().equals( superclass.getName() ) ); return null; }
orderedBaseClassElements.put( element.getPropertyName(), element ); baseReturnedClassOrElement = baseReturnedClassOrElement.getSuperclass(); XClass superClass = xClassProcessed.getSuperclass(); while ( superClass != null && superClass.isAnnotationPresent( MappedSuperclass.class ) ) { superClass = superClass.getSuperclass();
private void orderHierarchy(List<XClass> copy, List<XClass> newList, List<XClass> original, XClass clazz) { if ( clazz == null || reflectionManager.equals( clazz, Object.class ) ) { return; } //process superclass first orderHierarchy( copy, newList, original, clazz.getSuperclass() ); if ( original.contains( clazz ) ) { if ( !newList.contains( clazz ) ) { newList.add( clazz ); } copy.remove( clazz ); } }
public static InheritanceState getInheritanceStateOfSuperEntity( XClass clazz, Map<XClass, InheritanceState> states ) { XClass superclass = clazz; do { superclass = superclass.getSuperclass(); InheritanceState currentState = states.get( superclass ); if ( currentState != null && !currentState.isEmbeddableSuperclass() ) { return currentState; } } while ( superclass != null && !Object.class.getName().equals( superclass.getName() ) ); return 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(); } } }
private static void bindFilters(XClass annotatedClass, EntityBinder entityBinder, ExtendedMappings mappings) { bindFilters( annotatedClass, entityBinder ); XClass classToProcess = annotatedClass.getSuperclass(); while ( classToProcess != null ) { AnnotatedClassType classType = mappings.getClassType( classToProcess ); if ( AnnotatedClassType.EMBEDDABLE_SUPERCLASS.equals( classType ) ) { bindFilters( classToProcess, entityBinder ); } classToProcess = classToProcess.getSuperclass(); } }