@Override public BootstrapContext getBootstrapContext() { return rootBuildingContext.getBootstrapContext(); }
@Override public ConverterDescriptor toConverterDescriptor(MetadataBuildingContext context) { return new ClassBasedConverterDescriptor( attributeConverterClass, autoApply, context.getBootstrapContext().getClassmateContext() ); } }
@Override public ConverterDescriptor toConverterDescriptor(MetadataBuildingContext context) { return new InstanceBasedConverterDescriptor( attributeConverter, null, context.getBootstrapContext().getClassmateContext() ); } }
@Override public ConverterDescriptor toConverterDescriptor(MetadataBuildingContext context) { return new ClassBasedConverterDescriptor( attributeConverterClass, null, context.getBootstrapContext().getClassmateContext() ); } }
public ServiceRegistry getServiceRegistry() { if ( metadataBuildingContext != null ) { return metadataBuildingContext.getBootstrapContext().getServiceRegistry(); } else if ( sessionFactory != null ) { return sessionFactory.getServiceRegistry(); } return null; }
@Override public Class getIdType() { if ( javaType == null ) { javaType = buildingContext .getBootstrapContext() .getReflectionManager() .toClass( javaTypeXClass ); } return javaType; }
@Override public ConverterDescriptor toConverterDescriptor(MetadataBuildingContext context) { return new InstanceBasedConverterDescriptor( attributeConverter, autoApply, context.getBootstrapContext().getClassmateContext() ); } }
private static boolean isGlobalGeneratorNameGlobal(MetadataBuildingContext context) { return context.getBootstrapContext().getJpaCompliance().isGlobalGeneratorScopeEnabled(); }
public static boolean isDefault(XClass clazz, MetadataBuildingContext context) { return context.getBootstrapContext().getReflectionManager().equals( clazz, void.class ); }
public static Class reflectedPropertyClass( MetadataBuildingContext buildingContext, String attributeOwnerClassName, String attributeName) { final Class attributeOwnerClass = buildingContext.getBootstrapContext().getClassLoaderAccess().classForName( attributeOwnerClassName ); return reflectedPropertyClass( buildingContext, attributeOwnerClass, attributeName ); }
@Override public Class getIdType() { return buildingContext .getBootstrapContext() .getReflectionManager() .toClass( idXProperty.getType() ); }
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() ); }
public Class getProxyInterface() { if ( proxyInterfaceName == null ) { return null; } try { if ( proxyInterface == null ) { proxyInterface = metadataBuildingContext.getBootstrapContext().getClassLoaderAccess().classForName( proxyInterfaceName ); } return proxyInterface; } catch (ClassLoadingException e) { throw new MappingException( "proxy class not found: " + proxyInterfaceName, e ); } }
public Class getMappedClass() throws MappingException { if ( className == null ) { return null; } try { if ( mappedClass == null ) { mappedClass = metadataBuildingContext.getBootstrapContext().getClassLoaderAccess().classForName( className ); } return mappedClass; } catch (ClassLoadingException e) { throw new MappingException( "entity class not found: " + className, e ); } }
@Override public ConverterDescriptor toConverterDescriptor(MetadataBuildingContext context) { return new InstanceBasedConverterDescriptor( getAttributeConverter(), isAutoApply(), context.getBootstrapContext().getClassmateContext() ); } }
protected ConverterDescriptor makeAttributeConverterDescriptor(AttributeConversionInfo conversion) { try { return new ClassBasedConverterDescriptor( conversion.getConverterClass(), false, context.getBootstrapContext().getClassmateContext() ); } catch (Exception e) { throw new AnnotationException( "Unable to create AttributeConverter instance", e ); } }
public static XClass getTargetEntity(PropertyData propertyData, MetadataBuildingContext buildingContext) { XProperty property = propertyData.getProperty(); return buildingContext.getBootstrapContext().getReflectionManager().toXClass( getTargetEntityClass( property ) ); }
public static MappedSuperclass getMappedSuperclassOrNull( XClass declaringClass, Map<XClass, InheritanceState> inheritanceStatePerClass, MetadataBuildingContext context) { boolean retrieve = false; if ( declaringClass != null ) { final InheritanceState inheritanceState = inheritanceStatePerClass.get( declaringClass ); if ( inheritanceState == null ) { throw new org.hibernate.annotations.common.AssertionFailure( "Declaring class is not found in the inheritance state hierarchy: " + declaringClass ); } if ( inheritanceState.isEmbeddableSuperclass() ) { retrieve = true; } } if ( retrieve ) { return context.getMetadataCollector().getMappedSuperclass( context.getBootstrapContext().getReflectionManager().toClass( declaringClass ) ); } else { return null; } }
private void addPropertyToMappedSuperclass(Property prop, XClass declaringClass) { final Class type = getContext().getBootstrapContext().getReflectionManager().toClass( declaringClass ); MappedSuperclass superclass = getContext().getMetadataCollector().getMappedSuperclass( type ); superclass.addDeclaredProperty( prop ); }
@SuppressWarnings({ "unchecked" }) public void setProxy(Proxy proxy) { if ( proxy != null ) { lazy = proxy.lazy(); if ( !lazy ) { proxyClass = null; } else { final ReflectionManager reflectionManager = context.getBootstrapContext().getReflectionManager(); if ( AnnotationBinder.isDefault( reflectionManager.toXClass( proxy.proxyClass() ), context ) ) { proxyClass = annotatedClass; } else { proxyClass = reflectionManager.toXClass( proxy.proxyClass() ); } } } else { lazy = true; //needed to allow association lazy loading. proxyClass = annotatedClass; } }