public String getTypeName() throws MappingException { return returnedClass == null ? null : returnedClass.getName(); }
/** * Checks whether one class is assignable from another. If not {@link MappingException} is thrown. * * @param child Subclass. * @param parent Superclass. */ private void checkSuperclass(XClass child, XClass parent) { if ( !parent.isAssignableFrom( child ) ) { throw new MappingException( "Class " + parent.getName() + " is not assignable from " + child.getName() + ". " + "Please revise Envers annotations applied to " + child.getName() + " type." ); } }
@Override public AnnotatedClassType getClassType(XClass clazz) { AnnotatedClassType type = annotatedClassTypeMap.get( clazz.getName() ); if ( type == null ) { return addClassType( clazz ); } else { return type; } }
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; }
public String getTypeName() throws MappingException { return getPropertyClass().getName(); }
public String getClassOrElementName() throws MappingException { return getClassOrElement().getName(); }
private static boolean mustBeSkipped(XProperty property) { //TODO make those hardcoded tests more portable (through the bytecode provider?) return property.isAnnotationPresent( Transient.class ) || "net.sf.cglib.transform.impl.InterceptFieldCallback".equals( property.getType().getName() ) || "org.hibernate.bytecode.internal.javassist.FieldHandler".equals( property.getType().getName() ); } }
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; }
public static String getReferenceEntityName(PropertyData propertyData, XClass targetEntity, MetadataBuildingContext buildingContext) { if ( AnnotationBinder.isDefault( targetEntity, buildingContext ) ) { return propertyData.getClassOrElementName(); } else { return targetEntity.getName(); } }
@Override public void processEntityHierarchies(Set<String> processedEntityNames) { final List<XClass> orderedClasses = orderAndFillHierarchy( xClasses ); Map<XClass, InheritanceState> inheritanceStatePerClass = AnnotationBinder.buildInheritanceStates( orderedClasses, rootMetadataBuildingContext ); for ( XClass clazz : orderedClasses ) { if ( processedEntityNames.contains( clazz.getName() ) ) { log.debugf( "Skipping annotated class processing of entity [%s], as it has already been processed", clazz ); continue; } AnnotationBinder.bindClass( clazz, inheritanceStatePerClass, rootMetadataBuildingContext ); processedEntityNames.add( clazz.getName() ); } }
private static void checkAnyMetaDefValidity(boolean mustHaveName, AnyMetaDef defAnn, XAnnotatedElement annotatedElement) { if ( mustHaveName && isEmptyAnnotationValue( defAnn.name() ) ) { String name = XClass.class.isAssignableFrom( annotatedElement.getClass() ) ? ( (XClass) annotatedElement ).getName() : ( (XPackage) annotatedElement ).getName(); throw new AnnotationException( "@AnyMetaDef.name cannot be null on an entity or a package: " + name ); } }
public static String getReferenceEntityName(PropertyData propertyData, MetadataBuildingContext buildingContext) { XClass targetEntity = getTargetEntity( propertyData, buildingContext ); if ( AnnotationBinder.isDefault( targetEntity, buildingContext ) ) { return propertyData.getClassOrElementName(); } else { return targetEntity.getName(); } }
@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; }
/** * @param clazz Source class. * * @return List of @AuditOverride annotations applied at class level. */ private List<AuditOverride> computeAuditOverrides(XClass clazz) { final AuditOverrides auditOverrides = clazz.getAnnotation( AuditOverrides.class ); final AuditOverride auditOverride = clazz.getAnnotation( AuditOverride.class ); if ( auditOverrides == null && auditOverride != null ) { return Arrays.asList( auditOverride ); } else if ( auditOverrides != null && auditOverride == null ) { return Arrays.asList( auditOverrides.value() ); } else if ( auditOverrides != null && auditOverride != null ) { throw new MappingException( "@AuditOverrides annotation should encapsulate all @AuditOverride declarations. " + "Please revise Envers annotations applied to class " + clazz.getName() + "." ); } return Collections.emptyList(); }
private void assertTypesAreResolvable() { for ( XProperty xProperty : persistentAttributeMap.values() ) { if ( !xProperty.isTypeResolved() && !discoverTypeWithoutReflection( xProperty ) ) { String msg = "Property " + StringHelper.qualify( xClass.getName(), xProperty.getName() ) + " has an unbound type and no explicit target entity. Resolve this Generic usage issue" + " or set an explicit target attribute (eg @OneToMany(target=) or use an explicit @Type"; throw new AnnotationException( msg ); } } } //
/** * Checks whether class contains property with a given name. If not {@link MappingException} is thrown. * * @param clazz Class. * @param propertyName Property name. * * @return Property object. */ private XProperty getProperty(XClass clazz, String propertyName) { final XProperty property = ReflectionTools.getProperty( clazz, propertyName ); if ( property == null ) { throw new MappingException( "Property '" + propertyName + "' not found in class " + clazz.getName() + ". " + "Please revise Envers annotations applied to class " + persistentPropertiesSource.getXClass() + "." ); } return property; }
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 static PersistentClass getSuperEntity( XClass clazzToProcess, Map<XClass, InheritanceState> inheritanceStatePerClass, MetadataBuildingContext context, InheritanceState inheritanceState) { InheritanceState superEntityState = InheritanceState.getInheritanceStateOfSuperEntity( clazzToProcess, inheritanceStatePerClass ); PersistentClass superEntity = superEntityState != null ? context.getMetadataCollector().getEntityBinding( superEntityState.getClazz().getName() ) : null; if ( superEntity == null ) { //check if superclass is not a potential persistent class if ( inheritanceState.hasParents() ) { throw new AssertionFailure( "Subclass has to be binded after it's mother class: " + superEntityState.getClazz().getName() ); } } return superEntity; }
private void bindEjb3Annotation(Entity ejb3Ann) { if ( ejb3Ann == null ) throw new AssertionFailure( "@Entity should always be not null" ); if ( BinderHelper.isEmptyAnnotationValue( ejb3Ann.name() ) ) { name = StringHelper.unqualify( annotatedClass.getName() ); } else { name = ejb3Ann.name(); } }
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; }